maka-agent 0.2.0-dev.68.20261003 → 0.2.0-dev.70.20261005

package/node_modules/@maka/core/dist/recall.js

@@ -682,6 +682,18 @@ async function collectHits(deps, input) {
             scannedFully = false;
         }
     }
+    // A narrowed scan needs the corpus count to rank the same way as a full
+    // scan. Resolve it before reading transcripts so a declined count cannot
+    // discard work and reread every candidate during fallback.
+    const storedCorpusSize = deps.countSearchableMessages
+        ? await deps.countSearchableMessages({ sessionIds: input.sessionIds })
+        : null;
+    if (input.abortSignal?.aborted)
+        return null;
+    if (storedCorpusSize === null && !scannedFully) {
+        sessionIds = input.sessionIds;
+        scannedFully = true;
+    }
     const hits = [];
     let counted = 0;
     for (const sessionId of sessionIds) {
@@ -711,20 +723,7 @@ async function collectHits(deps, input) {
                 hits.push(hit);
         }
     }
-    // The narrowed path never sees the Sessions it skipped, so its corpus size
-    // has to come from the store. The full scan takes the same number when the
-    // store offers one, which is what keeps a score independent of the path.
-    let corpusSize = counted;
-    if (deps.countSearchableMessages) {
-        corpusSize = await deps.countSearchableMessages({ sessionIds: input.sessionIds });
-        if (input.abortSignal?.aborted)
-            return null;
-        if (corpusSize === null) {
-            if (!scannedFully)
-                return collectHits(deps, { ...input, forceFullScan: true });
-            corpusSize = counted;
-        }
-    }
+    const corpusSize = storedCorpusSize ?? counted;
     return { hits, corpusSize, scannedFully, transcripts };
 }
 /**

package/node_modules/@maka/runtime/dist/ai-sdk-turn.js

@@ -1127,9 +1127,6 @@ export class AiSdkTurn {
                     }
                     const requestSystemPromptBase = joinPromptFragments([
                         systemPrompt,
-                        priorUnknownProjection.kind === 'projected'
-                            ? priorUnknownProjection.systemNotice
-                            : undefined,
                         finalChildSummaryStep ? CHILD_STEP_BUDGET_FINALIZATION_PROMPT : undefined,
                         toolRuntime.hasSandboxBoundaryDenial() ? SANDBOX_BOUNDARY_DENIED_FOR_TURN : undefined,
                         sandboxBoundaryFinalizationStep ? SANDBOX_BOUNDARY_FINALIZATION_PROMPT : undefined,

package/node_modules/@maka/runtime/dist/model-history.js

@@ -177,20 +177,10 @@ export function inspectPriorUnknownToolOutcomes(events, invocations) {
     }
     if (outcomes.length === 0)
         return { kind: 'none' };
-    const rows = outcomes
-        .slice(0, 64)
-        .map((outcome) => `- ${outcome.toolName} (operation ${outcome.operationId})`);
-    if (outcomes.length > 64)
-        rows.push(`- and ${outcomes.length - 64} more unknown operations`);
-    return {
-        kind: 'projected',
-        outcomes,
-        systemNotice: [
-            'A prior execution was interrupted after these tools were dispatched. No durable tool results were recorded; their side effects may or may not have happened.',
-            'The outcome_unknown tool responses in history are temporary context, not proof of success or failure. Inspect current state before repeating any action.',
-            ...rows,
-        ].join('\n'),
-    };
+    // The unknown is carried only by the request-local tool responses below
+    // (appendPriorUnknownToolResponses): the system prompt stays byte-stable,
+    // so the provider's cached request prefix is never churned per event.
+    return { kind: 'projected', outcomes };
 }
 /** Insert request-only tool responses beside their calls so provider history stays well-formed. */
 export function appendPriorUnknownToolResponses(events, projection) {

package/node_modules/@maka/runtime/dist/runtime-read-model.js

@@ -42,9 +42,23 @@ export class RuntimeReadModel {
     async getSessionView(sessionId) {
         const diagnostics = [];
         const inFlightTurnIds = new Set();
+        let snapshot;
+        if (this.deps.runtimeEventStore.readSessionRuntimeSnapshot) {
+            try {
+                snapshot = await this.deps.runtimeEventStore.readSessionRuntimeSnapshot(sessionId);
+            }
+            catch (error) {
+                throw new RuntimeReadModelError('RuntimeEvent Session snapshot read failed', [
+                    readModelDiagnostic('unsupported_event', 'RuntimeEventStore.readSessionRuntimeSnapshot failed', {
+                        error: errorMessage(error),
+                    }),
+                ]);
+            }
+        }
         let invocations;
         try {
-            invocations = (await this.deps.runtimeEventStore.listSessionInvocations(sessionId)).filter((invocation) => isSessionInlineInvocation(invocation.opening));
+            invocations = (snapshot?.invocations ??
+                (await this.deps.runtimeEventStore.listSessionInvocations(sessionId))).filter((invocation) => isSessionInlineInvocation(invocation.opening));
         }
         catch (error) {
             throw new RuntimeReadModelError('RuntimeReadModel could not list Session invocations', [
@@ -56,15 +70,20 @@ export class RuntimeReadModel {
         if (invocations.length === 0) {
             return this.buildView({ invocations, events: [], diagnostics });
         }
-        const durableEventOrdinals = await this.readSessionRuntimeEventOrdinals(sessionId);
-        const durableEventOrdinalById = new Map(durableEventOrdinals.map(({ event, ordinal }) => [event.id, ordinal]));
+        const durableEventOrdinalById = snapshot?.durableEventOrdinalById ??
+            new Map((await this.readSessionRuntimeEventOrdinals(sessionId)).map(({ event, ordinal }) => [
+                event.id,
+                ordinal,
+            ]));
         const ordered = [];
         const terminalFacts = [];
         for (let runIndex = 0; runIndex < invocations.length; runIndex += 1) {
             const invocation = invocations[runIndex];
             let runEvents;
             try {
-                runEvents = await this.deps.runtimeEventStore.readRuntimeEvents(sessionId, invocation.runId);
+                runEvents = snapshot
+                    ? (snapshot.eventsByRun.get(invocation.runId) ?? [])
+                    : await this.deps.runtimeEventStore.readRuntimeEvents(sessionId, invocation.runId);
             }
             catch (error) {
                 throw new RuntimeReadModelError('RuntimeEvent ledger read failed', [

package/node_modules/@maka/storage/dist/execution-stores.js

@@ -354,6 +354,11 @@ async function createExecutionStoresForWrite(lease, provider) {
             ensureTerminalRuntimeEventDurable: (sessionId, runId, event) => run(() => runtimeEventStore.ensureTerminalRuntimeEventDurable(sessionId, runId, event)),
             ensureRecoveredTerminalRuntimeEventDurable: (sessionId, runId, event, operationIds) => run(() => runtimeEventStore.ensureRecoveredTerminalRuntimeEventDurable(sessionId, runId, event, operationIds)),
             readRuntimeEvents: (sessionId, runId) => run(() => runtimeEventStore.readRuntimeEvents(sessionId, runId)),
+            ...(runtimeEventStore.readSessionRuntimeSnapshot
+                ? {
+                    readSessionRuntimeSnapshot: (sessionId) => run(() => runtimeEventStore.readSessionRuntimeSnapshot(sessionId)),
+                }
+                : {}),
             scanRuntimeEvents: (sessionId, runId, budget, visit) => run(() => runtimeEventStore.scanRuntimeEvents(sessionId, runId, budget, visit)),
             readRuntimeEventsBounded: (sessionId, runId, budget) => run(() => runtimeEventStore.readRuntimeEventsBounded(sessionId, runId, budget)),
             readImmutableRuntimeEvents: (sessionId, runId) => run(() => runtimeEventStore.readImmutableRuntimeEvents(sessionId, runId)),
@@ -466,6 +471,11 @@ async function openExecutionStoresForRead(lease, kind, extension) {
         },
         runtimeEventStore: {
             readRuntimeEvents: (sessionId, runId) => run(() => runtimeEventStore.readRuntimeEvents(sessionId, runId)),
+            ...(runtimeEventStore.readSessionRuntimeSnapshot
+                ? {
+                    readSessionRuntimeSnapshot: (sessionId) => run(() => runtimeEventStore.readSessionRuntimeSnapshot(sessionId)),
+                }
+                : {}),
             readRuntimeEventsBounded: (sessionId, runId, budget) => run(() => runtimeEventStore.readRuntimeEventsBounded(sessionId, runId, budget)),
             readImmutableRuntimeEvents: (sessionId, runId) => run(() => runtimeEventStore.readImmutableRuntimeEvents(sessionId, runId)),
             listSessionInvocations: (sessionId) => run(() => runtimeEventStore.listSessionInvocations(sessionId)),

package/node_modules/@maka/storage/dist/runtime-event-persistence.js

@@ -39,6 +39,7 @@ export async function openRuntimeEventReadPersistence(input) {
     return {
         kind: 'sqlite',
         runtimeEventStore: Object.freeze({
+            readSessionRuntimeSnapshot: (sessionId) => store.readSessionRuntimeSnapshot(sessionId),
             listSessionInvocations: (sessionId) => store.listSessionInvocations(sessionId),
             listInvocationRecoveryInventory: (sessionIds) => store.listInvocationRecoveryInventory(sessionIds),
             readRunInvocation: (sessionId, runId) => store.readRunInvocation(sessionId, runId),

package/node_modules/@maka/storage/dist/sqlite-runtime-store.js

@@ -369,6 +369,74 @@ export class SqliteRuntimeStore {
     async readRuntimeEvents(sessionId, runId) {
         return this.readRuntimeEventsSync(sessionId, runId);
     }
+    async readSessionRuntimeSnapshot(sessionId) {
+        assertRuntimeStorageSafeId(sessionId, 'Invalid session id');
+        return this.readTransaction(() => {
+            const decodedEvents = new Map();
+            const openings = this.readInvocationOpeningsSync(sessionId, { direction: 'asc' }, decodedEvents);
+            const eventsByRun = new Map();
+            const durableEventOrdinalById = new Map();
+            if (openings.length === 0) {
+                return { invocations: [], eventsByRun, durableEventOrdinalById };
+            }
+            // Read each payload once. The opening query already decoded its events;
+            // reuse those same objects. Global event_seq order also gives each run
+            // its immutable order and each invocation its first terminal fact.
+            const rows = this.db
+                .prepare(`
+        SELECT event_id, session_id, invocation_id, run_id, turn_id,
+          CASE WHEN event_kind = 'invocation_opened' THEN '' ELSE payload_json END AS payload_json
+        FROM runtime_events
+        WHERE session_id = ?
+        ORDER BY event_seq ASC, event_id ASC
+      `)
+                .all(sessionId);
+            const terminalByInvocation = new Map();
+            for (const row of rows) {
+                const event = decodedEvents.get(row.event_id) ?? decodeRuntimeEventStorageRow(row);
+                const events = eventsByRun.get(event.runId) ?? [];
+                events.push(event);
+                eventsByRun.set(event.runId, events);
+                if (isTerminalRuntimeEvent(event) && !terminalByInvocation.has(event.invocationId)) {
+                    terminalByInvocation.set(event.invocationId, event);
+                }
+            }
+            // Only identities and ordinals are needed here, not a second copy of
+            // every payload. Keep the same join and identity checks as the entry reader.
+            const ordinals = this.db
+                .prepare(`
+        SELECT o.ordinal, e.event_id, e.session_id
+        FROM runtime_session_event_ordinals o
+        JOIN runtime_events e ON e.event_id = o.event_id
+        WHERE o.session_id = ?
+        ORDER BY o.ordinal ASC
+      `)
+                .all(sessionId);
+            for (const row of ordinals) {
+                if (!Number.isSafeInteger(row.ordinal) || row.ordinal < 1) {
+                    throw new Error(`Invalid RuntimeEvent Session ordinal for ${sessionId}`);
+                }
+                if (row.session_id !== sessionId) {
+                    throw new Error(`RuntimeEvent Session ordinal identity mismatch for ${row.event_id}`);
+                }
+                durableEventOrdinalById.set(row.event_id, row.ordinal);
+            }
+            const partialsByRun = new Map();
+            for (const partial of this.readRuntimePartialSnapshotsSync(sessionId)) {
+                const partials = partialsByRun.get(partial.event.runId) ?? [];
+                partials.push(partial);
+                partialsByRun.set(partial.event.runId, partials);
+            }
+            for (const [runId, partials] of partialsByRun) {
+                eventsByRun.set(runId, mergeRuntimePartialSnapshots(eventsByRun.get(runId) ?? [], partials));
+            }
+            const invocations = openings.map((opening) => {
+                const terminalEvent = terminalByInvocation.get(opening.invocationId);
+                return { ...opening, ...(terminalEvent ? { terminalEvent } : {}) };
+            });
+            return { invocations, eventsByRun, durableEventOrdinalById };
+        });
+    }
     transcriptQuery() {
         return new RuntimeTranscriptQuery(this.db, (sessionId, invocationId) => {
             // By invocation rather than by run: both shelves key their opening on it,
@@ -692,7 +760,7 @@ export class SqliteRuntimeStore {
      * Ordering and paging therefore happen in SQL, and a bounded caller decodes
      * only the openings it asked for.
      */
-    readInvocationOpeningsSync(sessionId, options) {
+    readInvocationOpeningsSync(sessionId, options, decodedEvents) {
         const order = options.direction === 'desc' ? 'DESC' : 'ASC';
         const rows = this.db
             .prepare(`
@@ -767,6 +835,7 @@ export class SqliteRuntimeStore {
             if (!opening) {
                 throw new Error(`RuntimeEvent ${event.id} is indexed as an opening fact but is not one`);
             }
+            decodedEvents?.set(event.id, event);
             return {
                 sessionId: event.sessionId,
                 invocationId: event.invocationId,
@@ -958,10 +1027,10 @@ export class SqliteRuntimeStore {
       SELECT stream_key, session_id, invocation_id, run_id, turn_id,
         payload_json, text_content, after_event_id
       FROM runtime_partial_snapshots
-      WHERE session_id = ? AND run_id = ?
+      WHERE session_id = ? ${runId === undefined ? '' : 'AND run_id = ?'}
       ORDER BY updated_at ASC, stream_key ASC
       `)
-            .all(sessionId, runId);
+            .all(...(runId === undefined ? [sessionId] : [sessionId, runId]));
         const segmentText = new Map();
         const segments = this.db
             .prepare(`
@@ -969,10 +1038,10 @@ export class SqliteRuntimeStore {
       FROM runtime_partial_segments AS segment
       INNER JOIN runtime_partial_snapshots AS snapshot
         ON snapshot.stream_key = segment.stream_key
-      WHERE snapshot.session_id = ? AND snapshot.run_id = ?
+      WHERE snapshot.session_id = ? ${runId === undefined ? '' : 'AND snapshot.run_id = ?'}
       ORDER BY segment.stream_key ASC, segment.segment_seq ASC
     `)
-            .iterate(sessionId, runId);
+            .iterate(...(runId === undefined ? [sessionId] : [sessionId, runId]));
         let streamKey;
         let chunks = [];
         let tail = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maka-agent",
-  "version": "0.2.0-dev.68.20261003",
+  "version": "0.2.0-dev.70.20261005",
   "description": "Apache Maka (Incubating) developer snapshot; not an Apache release.",
   "license": "Apache-2.0",
   "type": "module",