@loicngr/kobo 2.1.7 → 2.1.10

package/dist/server/services/agent/orchestrator.js

@@ -11,6 +11,8 @@ import * as cleanupScriptService from '../cleanup-script-service.js';
 import * as cronService from '../cron-service.js';
 import { resolveForge } from '../forge/resolve.js';
 import * as lifecycleHookService from '../lifecycle-hook-service.js';
+import { advanceMemoryConversationEpoch, allocateMemoryConversationKey, bindMemoryNativeConversation, createMemoryCapability, revokeMemoryCapability, } from '../memory-agent-runtime.js';
+import { buildMemoryContext, markMemoryContextFailed, markMemoryContextInitialized, markMemoryContextSubmitted, } from '../memory-context-service.js';
 import * as quotaBackoffService from '../quota-backoff-service.js';
 import { buildReviewReturnPrompt, getReviewReturn, restoreReviewConfiguration } from '../review-return-service.js';
 import { activateSession, SESSION_RECENCY_ORDER } from '../session-activity-service.js';
@@ -486,7 +488,7 @@ function readEffectiveSettingsSafe(projectPath) {
         };
     }
 }
-function buildMcpServers(workspaceId, extraEnv) {
+function buildMcpServers(workspaceId, extraEnv, memoryCapability) {
     const mcpServerCompiled = getCompiledMcpServerPath();
     const mcpServerSource = getMcpServerSourcePath();
     return [
@@ -497,6 +499,7 @@ function buildMcpServers(workspaceId, extraEnv) {
             env: {
                 KOBO_WORKSPACE_ID: workspaceId,
                 ...extraEnv,
+                ...(memoryCapability ? { KOBO_MEMORY_SESSION_TOKEN: memoryCapability } : {}),
                 KOBO_DB_PATH: getDbPath(),
                 KOBO_SETTINGS_PATH: getSettingsPath(),
                 KOBO_BACKEND_URL: `http://127.0.0.1:${backendPort}`,
@@ -842,6 +845,13 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev, terminal
     // stop — see `sourceControllerIsStopping` further down.
     if (sourceNoLongerOwnsWorkspace && ev.kind !== 'session:ended')
         return;
+    if (sourceController && ev.kind === 'session:started') {
+        const conversationKey = controllerMemoryConversationKeys.get(sourceController);
+        if (conversationKey)
+            bindMemoryNativeConversation(conversationKey, ev.engineSessionId);
+    }
+    if (sourceController && ev.kind === 'session:ended' && terminalAfterClose)
+        revokeControllerMemoryCapability(sourceController);
     // A controller already told to stop (D1) keeps emitting real events until it
     // actually dies — they are persisted and broadcast like any other (see
     // `routeEvent` below, unconditional). But a handful of side effects here
@@ -861,6 +871,34 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev, terminal
     if (launch?.handoffGeneration &&
         !['session:started', 'session:ended', 'session:user-input-requested'].includes(ev.kind))
         return;
+    if (sourceController &&
+        !sourceControllerIsStopping &&
+        controllers.get(workspaceId) === sourceController &&
+        pendingStarts.get(workspaceId) === undefined) {
+        const compaction = memoryCompactionStates.get(sourceController) ?? { active: false, compactedWithoutId: false };
+        if (ev.kind === 'session:compacting' && ev.active) {
+            compaction.active = true;
+            compaction.compactedWithoutId = false;
+            if (ev.compactionId)
+                compaction.activeId = ev.compactionId;
+            memoryCompactionStates.set(sourceController, compaction);
+        }
+        else if (ev.kind === 'session:compacted') {
+            const duplicateId = ev.compactionId !== undefined && ev.compactionId === compaction.lastId;
+            const hasDistinctSignal = ev.compactionId !== undefined ? !duplicateId : compaction.active || !compaction.compactedWithoutId;
+            if (hasDistinctSignal) {
+                const conversationKey = controllerMemoryConversationKeys.get(sourceController);
+                if (conversationKey)
+                    advanceMemoryConversationEpoch(conversationKey);
+                if (ev.compactionId)
+                    compaction.lastId = ev.compactionId;
+                compaction.compactedWithoutId = true;
+            }
+            compaction.active = false;
+            compaction.activeId = undefined;
+            memoryCompactionStates.set(sourceController, compaction);
+        }
+    }
     if (sourceController && !sourceControllerIsStopping) {
         if (ev.kind === 'session:compacting' && ev.active) {
             const status = getWs(workspaceId)?.status;
@@ -1298,6 +1336,17 @@ function onSessionEnded(workspaceId, agentSessionId, sourceController, exitCode,
     return true;
 }
 const launchOptions = new WeakMap();
+const controllerMemoryCapabilities = new WeakMap();
+const controllerMemoryConversationKeys = new WeakMap();
+const controllerMemoryContextIds = new WeakMap();
+const memoryCompactionStates = new WeakMap();
+function revokeControllerMemoryCapability(controller) {
+    const token = controllerMemoryCapabilities.get(controller);
+    if (!token)
+        return;
+    revokeMemoryCapability(token);
+    controllerMemoryCapabilities.delete(controller);
+}
 // ── Public API ────────────────────────────────────────────────────────────────
 /**
  * Spawn an agent (via the resolved engine) for a workspace. Returns
@@ -1384,6 +1433,22 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
     // A review whose report returns to the original session must end by itself:
     // enforce read-only plan mode here, not only through its prompt.
     const readOnly = getReviewReturn(workspaceId, agentSessionId) !== null;
+    const effectivePermissionMode = readOnly ? 'plan' : (agentPermissionMode ?? ws?.agentPermissionMode ?? 'bypass');
+    const memoryDispatchId = nanoid();
+    const memoryCapability = createMemoryCapability({
+        dispatchId: memoryDispatchId,
+        workspaceId,
+        sessionId: agentSessionId,
+        engine: engine.id,
+        // A resume continues its prior native conversation; a fresh dispatch starts
+        // a separate context even if application session selection is reused.
+        conversationKey: allocateMemoryConversationKey({
+            sessionId: agentSessionId,
+            engine: engine.id,
+            ...(resumeFromEngineSessionId ? { nativeConversationId: resumeFromEngineSessionId } : {}),
+        }),
+        readOnly: effectivePermissionMode === 'plan' || !!launch?.handoffGeneration,
+    });
     const unavailableIntegrations = [];
     const integrationServers = buildIntegrationMcpServers(getGlobalSettings(), engine.id, (name) => unavailableIntegrations.push(name));
     const options = {
@@ -1393,7 +1458,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         model,
         effort: reasoningEffort,
         // Cascade: explicit caller override → workspace setting → 'bypass'.
-        agentPermissionMode: readOnly ? 'plan' : (agentPermissionMode ?? ws?.agentPermissionMode ?? 'bypass'),
+        agentPermissionMode: effectivePermissionMode,
         readOnly,
         resumeFromEngineSessionId,
         backendUrl: `http://127.0.0.1:${backendPort}`,
@@ -1406,12 +1471,23 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
             }
         })(),
         settings,
-        mcpServers: [...buildMcpServers(workspaceId, launch?.mcpEnv), ...integrationServers],
+        mcpServers: [...buildMcpServers(workspaceId, launch?.mcpEnv, memoryCapability.token), ...integrationServers],
         env: ws ? buildAgentEnv(ws.projectPath) : undefined,
     };
-    beforeDispatch?.();
+    try {
+        beforeDispatch?.();
+    }
+    catch (error) {
+        revokeMemoryCapability(memoryCapability.token);
+        throw error;
+    }
     let controller;
     controller = new SessionController(workspaceId, agentSessionId, engine, (ev) => handleEvent(workspaceId, agentSessionId, controller, ev));
+    controllerMemoryCapabilities.set(controller, memoryCapability.token);
+    controllerMemoryConversationKeys.set(controller, memoryCapability.conversationKey);
+    // This promise settles only after the controller confirms actual process
+    // closure, covering direct stop() paths that do not emit session:ended.
+    void controller.closed.then(() => revokeControllerMemoryCapability(controller));
     if (launch)
         launchOptions.set(controller, launch);
     registerSessionLifecycleOwner(workspaceId, agentSessionId, controller);
@@ -1438,11 +1514,33 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         if (registered && registered !== controller)
             throw new Error('Agent is still stopping');
         controllers.set(workspaceId, controller);
+        const memoryContext = launch?.handoffGeneration
+            ? undefined
+            : buildMemoryContext({
+                workspaceId,
+                sessionId: agentSessionId,
+                engine: engine.id,
+                dispatchId: memoryDispatchId,
+                conversationKey: memoryCapability.conversationKey,
+                resume: Boolean(resumeFromEngineSessionId),
+                readOnly: effectivePermissionMode === 'plan' || !!launch?.handoffGeneration,
+                mode: getGlobalSettings().memoryMode,
+            });
+        if (memoryContext) {
+            controllerMemoryContextIds.set(controller, memoryContext.recordId);
+            options.prompt = `${options.prompt}\n\n${memoryContext.prompt}`;
+            markMemoryContextSubmitted(memoryContext.recordId);
+        }
         return controller.start(options);
     })
         .then(async () => {
-        if (launch?.onStarted)
-            await controller.engineProcess?.ready;
+        const ready = controller.engineProcess?.ready;
+        const contextId = controllerMemoryContextIds.get(controller);
+        if (ready && contextId) {
+            void ready.then(() => markMemoryContextInitialized(contextId), () => markMemoryContextFailed(contextId));
+        }
+        if (launch?.onStarted && ready)
+            await ready;
         if (controller.status !== 'stopping')
             launch?.onStarted?.();
         const pid = controller.pid;
@@ -1457,6 +1555,10 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         }
     })
         .catch((err) => {
+        revokeControllerMemoryCapability(controller);
+        const contextId = controllerMemoryContextIds.get(controller);
+        if (contextId)
+            markMemoryContextFailed(contextId);
         if (existingCtrl && controller.status === 'stopping')
             return;
         console.error('[orchestrator] engine.start failed:', err);
@@ -1532,6 +1634,7 @@ export function stopSubagents(workspaceId, id) {
 /** Bound the caller's wait, retaining ownership until actual engine shutdown. */
 export const STOP_AGENT_TIMEOUT_MS = 15_000;
 async function stopController(workspaceId, ctrl, cause = 'user') {
+    revokeControllerMemoryCapability(ctrl);
     ctrl.stopCause = cause;
     restoreReviewConfiguration(workspaceId, ctrl.agentSessionId);
     preCompactionStatus.delete(ctrl);
@@ -1615,6 +1718,7 @@ cause = 'user') {
     let pendingStop = Promise.resolve();
     if (pending) {
         pendingStarts.delete(workspaceId);
+        revokeControllerMemoryCapability(pending);
         pending.stopCause = cause;
         pendingStop = pending.stop().then(() => {
             handleEvent(workspaceId, pending.agentSessionId, pending, {

package/dist/server/services/memory-agent-runtime.js

@@ -0,0 +1,65 @@
+import { randomBytes } from 'node:crypto';
+import { nanoid } from 'nanoid';
+import { getDb } from '../db/index.js';
+const activeCapabilities = new Map();
+/** Persist an opaque conversation key independently from a controller/token generation. */
+export function allocateMemoryConversationKey(input) {
+    const db = getDb();
+    if (input.nativeConversationId) {
+        const existing = db
+            .prepare(`SELECT conversation_key FROM memory_budget_contexts
+        WHERE kind = 'internal' AND session_id = ? AND engine = ? AND native_conversation_id = ?
+        ORDER BY updated_at DESC LIMIT 1`)
+            .get(input.sessionId, input.engine, input.nativeConversationId);
+        if (existing)
+            return existing.conversation_key;
+    }
+    const key = nanoid();
+    const timestamp = new Date().toISOString();
+    db.prepare(`INSERT INTO memory_budget_contexts
+    (id, kind, session_id, engine, conversation_key, native_conversation_id, epoch,
+      cumulative_estimated_tokens, delivered_json, created_at, updated_at)
+    VALUES (?, 'internal', ?, ?, ?, ?, 0, 0, '[]', ?, ?)`).run(nanoid(), input.sessionId, input.engine, key, input.nativeConversationId ?? null, timestamp, timestamp);
+    return key;
+}
+/** Bind a fresh conversation's native provider id once the engine confirms it. */
+export function bindMemoryNativeConversation(key, nativeConversationId) {
+    const timestamp = new Date().toISOString();
+    getDb()
+        .prepare(`UPDATE memory_budget_contexts SET native_conversation_id = ?, updated_at = ?
+      WHERE kind = 'internal' AND conversation_key = ? AND epoch = 0 AND native_conversation_id IS NULL`)
+        .run(nativeConversationId, timestamp, key);
+}
+/** Start a new metadata-only ledger epoch after the owning controller confirms compaction. */
+export function advanceMemoryConversationEpoch(key) {
+    const db = getDb();
+    const current = db
+        .prepare(`SELECT id, session_id, engine, native_conversation_id, epoch FROM memory_budget_contexts
+      WHERE kind = 'internal' AND conversation_key = ? ORDER BY epoch DESC LIMIT 1`)
+        .get(key);
+    if (!current)
+        return undefined;
+    const id = nanoid();
+    const epoch = current.epoch + 1;
+    const timestamp = new Date().toISOString();
+    db.prepare(`INSERT INTO memory_budget_contexts
+    (id, kind, session_id, engine, conversation_key, native_conversation_id, epoch,
+      cumulative_estimated_tokens, delivered_json, created_at, updated_at)
+    VALUES (?, 'internal', ?, ?, ?, ?, ?, 0, '[]', ?, ?)`).run(id, current.session_id, current.engine, key, current.native_conversation_id, epoch, timestamp, timestamp);
+    return { id, epoch };
+}
+/** Issue an unguessable, launch-specific capability. The raw value is process env only. */
+export function createMemoryCapability(descriptor) {
+    const token = randomBytes(32).toString('hex');
+    activeCapabilities.set(token, Object.freeze({ ...descriptor }));
+    return { token, conversationKey: descriptor.conversationKey };
+}
+export function getMemoryCapability(token) {
+    if (!token || !/^[a-f0-9]{64}$/.test(token))
+        return undefined;
+    return activeCapabilities.get(token);
+}
+/** Revokes only this launch secret, never another generation sharing its session id. */
+export function revokeMemoryCapability(token) {
+    activeCapabilities.delete(token);
+}

package/dist/server/services/memory-budget-service.js

@@ -0,0 +1,205 @@
+import { nanoid } from 'nanoid';
+import { MEMORY_CONVERSATION_BUDGET_TOKENS } from '../../shared/memory.js';
+import { getDb } from '../db/index.js';
+/** Metadata only: fingerprints never retain note bodies or prompt text. */
+export function getMemoryBootstrapFingerprint(budgetContextId) {
+    const row = getDb().prepare('SELECT delivered_json FROM memory_budget_contexts WHERE id = ?').get(budgetContextId);
+    if (!row)
+        return undefined;
+    try {
+        const records = JSON.parse(row.delivered_json);
+        if (!Array.isArray(records))
+            return undefined;
+        const record = records.reverse().find((item) => item?.kind === 'bootstrap');
+        if (typeof record?.guidanceHash === 'string' && typeof record?.snapshotHash === 'string')
+            return { guidanceHash: record.guidanceHash, snapshotHash: record.snapshotHash };
+    }
+    catch {
+        /* Legacy or malformed metadata cannot prove prior delivery. */
+    }
+    return undefined;
+}
+export function getInternalMemoryBudgetContext(conversationKey) {
+    const row = getDb()
+        .prepare(`SELECT id, epoch, cumulative_estimated_tokens AS cumulativeEstimatedTokens
+    FROM memory_budget_contexts WHERE kind = 'internal' AND conversation_key = ?
+    ORDER BY epoch DESC LIMIT 1`)
+        .get(conversationKey);
+    if (!row)
+        throw new TypeError('Internal memory budget ledger not found');
+    return row;
+}
+const MEMORY_DENIAL_RESERVE_TOKENS = 500;
+const MEMORY_REGULAR_OUTPUT_LIMIT = MEMORY_CONVERSATION_BUDGET_TOKENS - MEMORY_DENIAL_RESERVE_TOKENS;
+const BUDGET_DENIAL_MARKER = 'budget-denial';
+function now() {
+    return new Date().toISOString();
+}
+/** Create a new external handle or resolve one previously returned to the same client/transport. */
+export function createExternalMemoryBudgetContext(requestedId, clientName, transport) {
+    const db = getDb();
+    if (requestedId !== undefined) {
+        if (requestedId.length < 12 || requestedId.length > 128)
+            throw new TypeError('Invalid memory_context_id');
+        const row = db
+            .prepare(`SELECT id, kind, cumulative_estimated_tokens, client_name, transport
+      FROM memory_budget_contexts WHERE external_context_id = ? OR id = ?`)
+            .get(requestedId, requestedId);
+        if (row?.kind !== 'external' || row.id !== requestedId) {
+            throw new TypeError('Unknown external memory_context_id');
+        }
+        if (row.client_name !== clientName || row.transport !== transport) {
+            throw new TypeError('memory_context_id belongs to another external client context');
+        }
+        return { id: row.id, cumulativeEstimatedTokens: row.cumulative_estimated_tokens };
+    }
+    const id = nanoid(32);
+    const timestamp = now();
+    db.prepare(`INSERT INTO memory_budget_contexts
+    (id, kind, external_context_id, epoch, cumulative_estimated_tokens, delivered_json, client_name, transport, created_at, updated_at)
+    VALUES (?, 'external', ?, 0, 0, '[]', ?, ?, ?, ?)`).run(id, id, clientName.slice(0, 120), transport, timestamp, timestamp);
+    return { id, cumulativeEstimatedTokens: 0 };
+}
+/**
+ * Charges a native-conversation bootstrap or an MCP response using an immediate
+ * SQLite transaction, so concurrent sub-agents cannot spend the same allowance.
+ * Unknown/failed delivery is intentionally still charged.
+ */
+export function reserveMemoryBudget(input) {
+    if (!Number.isSafeInteger(input.estimatedTokens) || input.estimatedTokens < 1)
+        throw new TypeError('Memory budget charge must be a positive integer');
+    const responseLimitTokens = input.responseLimitTokens;
+    if (responseLimitTokens !== undefined && input.estimatedTokens > responseLimitTokens) {
+        return {
+            accepted: false,
+            budgetContextId: input.budgetContextId,
+            estimatedTokens: input.estimatedTokens,
+            remainingTokens: 0,
+            limitTokens: responseLimitTokens,
+            reason: 'response-limit',
+        };
+    }
+    const db = getDb();
+    return db
+        .transaction(() => {
+        const row = db
+            .prepare(`SELECT id, kind, cumulative_estimated_tokens, delivered_json
+      FROM memory_budget_contexts WHERE id = ?`)
+            .get(input.budgetContextId);
+        if (!row)
+            throw new TypeError('Memory budget ledger not found');
+        let delivered;
+        try {
+            const parsed = JSON.parse(row.delivered_json);
+            delivered = Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            delivered = [];
+        }
+        const denialAlreadyUsed = delivered.some((item) => item && typeof item === 'object' && item.kind === BUDGET_DENIAL_MARKER);
+        const remaining = denialAlreadyUsed
+            ? 0
+            : Math.max(0, MEMORY_REGULAR_OUTPUT_LIMIT - row.cumulative_estimated_tokens);
+        if (input.estimatedTokens > remaining) {
+            return {
+                accepted: false,
+                budgetContextId: row.id,
+                estimatedTokens: input.estimatedTokens,
+                remainingTokens: remaining,
+                limitTokens: MEMORY_REGULAR_OUTPUT_LIMIT,
+                reason: 'conversation-limit',
+            };
+        }
+        const newDeliveries = [...(input.deliveries ?? []), ...(input.delivery ? [input.delivery] : [])];
+        if (input.bootstrap) {
+            delivered = delivered.filter((item) => !item || typeof item !== 'object' || item.kind !== 'bootstrap');
+            delivered.push({ kind: 'bootstrap', ...input.bootstrap });
+        }
+        if (newDeliveries.length > 0) {
+            delivered.push(...newDeliveries);
+            if (delivered.length > 2_000)
+                delivered = delivered.slice(-2_000);
+        }
+        const cumulative = row.cumulative_estimated_tokens + input.estimatedTokens;
+        db.prepare(`UPDATE memory_budget_contexts SET cumulative_estimated_tokens = ?, delivered_json = ?, updated_at = ?
+      WHERE id = ?`).run(cumulative, JSON.stringify(delivered), now(), row.id);
+        return {
+            accepted: true,
+            budgetContextId: row.id,
+            estimatedTokens: input.estimatedTokens,
+            remainingTokens: MEMORY_REGULAR_OUTPUT_LIMIT - cumulative,
+            limitTokens: MEMORY_REGULAR_OUTPUT_LIMIT,
+        };
+    })
+        .immediate();
+}
+/** Spend one reserved terminal receipt; later exhausted calls are suppressed without output. */
+export function reserveMemoryBudgetDenial(budgetContextId, estimatedTokens) {
+    if (!Number.isSafeInteger(estimatedTokens) || estimatedTokens < 1 || estimatedTokens > MEMORY_DENIAL_RESERVE_TOKENS)
+        throw new TypeError('Memory budget denial receipt exceeds its reserved allowance');
+    const db = getDb();
+    return db
+        .transaction(() => {
+        const row = db
+            .prepare(`SELECT id, cumulative_estimated_tokens, delivered_json
+          FROM memory_budget_contexts WHERE id = ?`)
+            .get(budgetContextId);
+        if (!row)
+            throw new TypeError('Memory budget ledger not found');
+        let delivered;
+        try {
+            const parsed = JSON.parse(row.delivered_json);
+            delivered = Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            delivered = [];
+        }
+        const alreadyUsed = delivered.some((item) => item && typeof item === 'object' && item.kind === BUDGET_DENIAL_MARKER);
+        if (alreadyUsed || row.cumulative_estimated_tokens + estimatedTokens > MEMORY_CONVERSATION_BUDGET_TOKENS) {
+            return {
+                responseAllowed: false,
+                budgetContextId: row.id,
+                estimatedTokens: 0,
+                remainingTokens: Math.max(0, MEMORY_CONVERSATION_BUDGET_TOKENS - row.cumulative_estimated_tokens),
+                limitTokens: MEMORY_CONVERSATION_BUDGET_TOKENS,
+            };
+        }
+        delivered.push({ kind: BUDGET_DENIAL_MARKER, estimatedTokens });
+        const cumulative = row.cumulative_estimated_tokens + estimatedTokens;
+        db.prepare(`UPDATE memory_budget_contexts
+        SET cumulative_estimated_tokens = ?, delivered_json = ?, updated_at = ? WHERE id = ?`).run(cumulative, JSON.stringify(delivered), now(), row.id);
+        return {
+            responseAllowed: true,
+            budgetContextId: row.id,
+            estimatedTokens,
+            remainingTokens: MEMORY_CONVERSATION_BUDGET_TOKENS - cumulative,
+            limitTokens: MEMORY_CONVERSATION_BUDGET_TOKENS,
+        };
+    })
+        .immediate();
+}
+/** Returns delivery metadata only; persisted note bodies are never stored in this ledger. */
+export function wasMemoryFragmentDelivered(budgetContextId, delivery) {
+    const row = getDb()
+        .prepare('SELECT kind, delivered_json FROM memory_budget_contexts WHERE id = ?')
+        .get(budgetContextId);
+    if (!row)
+        return false;
+    try {
+        const items = JSON.parse(row.delivered_json);
+        return (Array.isArray(items) &&
+            items.some((item) => {
+                if (!item || typeof item !== 'object')
+                    return false;
+                const candidate = item;
+                return (candidate.entryId === delivery.entryId &&
+                    candidate.revision === delivery.revision &&
+                    candidate.kind === delivery.kind &&
+                    candidate.start === delivery.start &&
+                    candidate.end === delivery.end);
+            }));
+    }
+    catch {
+        return false;
+    }
+}