maka-agent 0.2.1-dev.88.20261016 → 0.2.1-dev.90.20261017

package/dist/pi-tui-layout.js

@@ -45,8 +45,8 @@ export function fitPendingQueueLines(lines, maxRows) {
  * The fullscreen chrome's editor/pending-queue row account, isolated in one
  * function so the budget and its consumers cannot drift apart: from the rows
  * available below the transcript, reserve the editor's minimum viewport (the
- * queue trims first), then give the editor whatever remains, never less than
- * that minimum while any budget is left to reserve it from. `rowsAvailable` is
+ * queue trims first), then report the actual remainder so the caller can
+ * detect a deficit and yield optional chrome. `rowsAvailable` is
  * everything already carved out of the terminal rows — the chrome subtracts the
  * status line, activity strip, unread indicator, and the reserved transcript row
  * before calling. The main-screen layout keeps its own (upstream-owned)
@@ -60,7 +60,7 @@ function budgetEditorAndPendingRows(rowsAvailable, allPendingLines, editor) {
     const pendingLines = fitPendingQueueLines(allPendingLines, pendingRowsAvailable);
     return {
         pendingLines,
-        editorRows: budget === 0 ? 0 : Math.max(minimumEditorRows, budget - pendingLines.length),
+        editorRows: Math.max(0, budget - pendingLines.length),
     };
 }
 export class MakaTranscriptComponent {

package/node_modules/@maka/core/dist/event-wait.js

@@ -29,7 +29,12 @@ export const EVENT_WAIT_LIMITS = Object.freeze({
     evidenceRefs: 8,
     evidenceRefBytes: 1024,
     reasonBytes: 1024,
-    recordBytes: 32768,
+    cursorBytes: 2048,
+    observationAttempts: 1_000_000,
+    // Every combination of bounded fields, including observation and a cancelled
+    // priorResolution, fits below 42 KiB even with JSON escaping. Leave room for
+    // the full lifecycle so an accepted result can always retain its facts on cancel.
+    recordBytes: 48 * 1024,
 });
 const encoder = new TextEncoder();
 const invalidIdCharacterPattern = /[^A-Za-z0-9_-]/u;
@@ -187,7 +192,7 @@ export function decodeEventWaitRecord(value) {
         'deadlineAt',
         'status',
         ...lifecycleKeys,
-    ], root.status === 'cancelled' ? ['priorResolution'] : []);
+    ], root.status === 'cancelled' ? ['priorResolution', 'observation'] : ['observation']);
     if (r.schemaVersion !== EVENT_WAIT_SCHEMA_VERSION)
         invalid('schemaVersion');
     const lease = shape(r.goalControlLease, ['goalId', 'generation']);
@@ -230,6 +235,62 @@ export function decodeEventWaitRecord(value) {
             invalid('lifecycle time');
         return result;
     };
+    if (Object.hasOwn(r, 'observation')) {
+        const x = shape(r.observation, [
+            'schemaVersion',
+            'attempts',
+            'lastAttemptAt',
+            'lastObservedAt',
+            'nextObserveAt',
+            'nextPollAt',
+            'consecutiveErrors',
+            'outcome',
+            'cursor',
+            'eventKey',
+            'reason',
+        ]);
+        const attempts = integer(x.attempts, 'observation attempts', 1);
+        const consecutiveErrors = integer(x.consecutiveErrors, 'consecutive errors');
+        const lastAttemptAt = time(x.lastAttemptAt);
+        const nextObserveAt = integer(x.nextObserveAt, 'next observation');
+        const nextPollAt = integer(x.nextPollAt, 'next poll');
+        const lastObservedAt = x.lastObservedAt === null ? null : time(x.lastObservedAt);
+        if (x.schemaVersion !== 1 ||
+            attempts > EVENT_WAIT_LIMITS.observationAttempts ||
+            consecutiveErrors > attempts ||
+            nextObserveAt < lastAttemptAt ||
+            nextPollAt < nextObserveAt ||
+            (x.outcome !== 'checking' && (lastObservedAt === null || lastObservedAt < lastAttemptAt)) ||
+            typeof x.outcome !== 'string' ||
+            ![
+                'checking',
+                'pending',
+                'unknown',
+                'satisfied',
+                'invalidated',
+                'source_unavailable',
+            ].includes(x.outcome))
+            invalid('observation');
+        Object.assign(base, {
+            observation: {
+                schemaVersion: 1,
+                attempts,
+                lastAttemptAt,
+                lastObservedAt,
+                nextObserveAt,
+                nextPollAt,
+                consecutiveErrors,
+                outcome: x.outcome,
+                cursor: x.cursor === null ? null : text(x.cursor, 'cursor', EVENT_WAIT_LIMITS.cursorBytes),
+                eventKey: x.eventKey === null
+                    ? null
+                    : text(x.eventKey, 'event key', EVENT_WAIT_LIMITS.receiptKeyBytes),
+                reason: x.reason === null
+                    ? null
+                    : text(x.reason, 'observation reason', EVENT_WAIT_LIMITS.reasonBytes),
+            },
+        });
+    }
     const resolution = (v, resolvedAt) => {
         const x = shape(v, ['outcome', 'receiptKey', 'observedAt', 'evidenceRefs']);
         if (x.outcome !== 'satisfied' &&
@@ -306,7 +367,41 @@ export function assertEventWaitTransition(previous, next) {
     }
     if (b.updatedAt < a.updatedAt)
         invalid('time regression');
+    if (a.observation) {
+        if (!b.observation ||
+            b.observation.attempts < a.observation.attempts ||
+            b.observation.attempts > a.observation.attempts + 1 ||
+            b.observation.lastAttemptAt < a.observation.lastAttemptAt ||
+            (a.observation.lastObservedAt !== null &&
+                (b.observation.lastObservedAt === null ||
+                    b.observation.lastObservedAt < a.observation.lastObservedAt)))
+            invalid('observation regression');
+        if (b.observation.attempts === a.observation.attempts &&
+            b.observation.lastAttemptAt !== a.observation.lastAttemptAt)
+            invalid('attempt time without reservation');
+        if (b.observation.attempts > a.observation.attempts &&
+            (b.status !== 'waiting' ||
+                b.observation.outcome !== 'checking' ||
+                b.observation.lastObservedAt !== a.observation.lastObservedAt ||
+                b.observation.cursor !== a.observation.cursor ||
+                b.observation.eventKey !== a.observation.eventKey ||
+                b.observation.consecutiveErrors !== a.observation.consecutiveErrors))
+            invalid('attempt reservation');
+    }
+    else if (b.observation && b.observation.attempts !== 1)
+        invalid('initial observation budget');
     if (a.status === 'waiting') {
+        if (b.status === 'waiting' && b.observation && !same(a.observation, b.observation)) {
+            if (b.observation.attempts > (a.observation?.attempts ?? 0) &&
+                b.observation.outcome === 'checking')
+                return;
+            if (a.observation?.outcome === 'checking' &&
+                (b.observation.outcome === 'pending' || b.observation.outcome === 'unknown'))
+                return;
+            invalid('observation update without reservation');
+        }
+        if (b.status === 'resolved' && b.resolvedAt >= b.deadlineAt)
+            invalid('resolution after deadline');
         if (b.status === 'resolved' ||
             b.status === 'expired' ||
             (b.status === 'cancelled' && !b.priorResolution))
@@ -314,6 +409,7 @@ export function assertEventWaitTransition(previous, next) {
     }
     else if (a.status === 'resolved' &&
         b.status === 'cancelled' &&
+        same(a.observation, b.observation) &&
         same(b.priorResolution, { resolvedAt: a.resolvedAt, resolution: a.resolution }))
         return;
     invalid('state transition');

package/node_modules/@maka/core/dist/llm-connections.js

@@ -359,8 +359,14 @@ export function deriveInteractiveOAuthConnectionSlug(providerType, existingSlugs
  *   - Any other scheme (`file:`, `javascript:`, `data:`, `vbscript:`,
  *     `chrome-extension:`, `app:`, `maka:`, custom).
  *   - Malformed URL strings the `URL` constructor throws on.
+ *   - Embedded credentials (`https://user:pw@host`), query strings and
+ *     fragments — the Runtime Host codec refuses these, so accepting
+ *     them here only turns the eventual rejection into the generic
+ *     "service unavailable" copy.
  *   - Pathological lengths (> 2048 chars — defense against
- *     adversarial inputs; real-world baseUrls are < 100 chars).
+ *     adversarial inputs; real-world baseUrls are < 100 chars) and
+ *     canonical forms longer than 2048 bytes, which is the unit the
+ *     Host measures.
  *
  * Returns `null` on accept, an error string on reject. Mirrors
  * `validateSlug`'s shape.
@@ -389,6 +395,18 @@ export function validateConnectionBaseUrl(baseUrl) {
     if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
         return `baseUrl scheme '${parsed.protocol}' is not allowed (use http: or https:)`;
     }
+    // The Runtime Host rejects these too (`normalizeCatalogConnectionBaseUrl`),
+    // so gating here is what turns a downstream, unclassified failure into a
+    // message that names the endpoint field.
+    if (parsed.username || parsed.password) {
+        return 'baseUrl must not contain credentials';
+    }
+    if (trimmed.includes('?') || trimmed.includes('#')) {
+        return 'baseUrl must not contain a query or fragment';
+    }
+    if (new TextEncoder().encode(parsed.toString()).byteLength > 2048) {
+        return 'baseUrl must be 2048 bytes or fewer';
+    }
     return null;
 }
 /**

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

@@ -18,8 +18,7 @@
  */
 import { compactionDecisionDiagnosticPatch } from './compaction-boundary.js';
 import { buildContextBudgetDiagnosticShell, mergeContextBudgetDiagnostic, mergeContextBudgetDiagnosticPatches, } from './context-budget.js';
-import { isHistoryCompactContentEvent } from './history-compaction.js';
-import { canContinueHistoryCompactCheckpointForModel, canReplayHistoryCompactCheckpointForModel, historyCompactSourceDigest, matchHistoryCompactCheckpointPrefix, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
+import { canContinueHistoryCompactCheckpointForModel, canReplayHistoryCompactCheckpointForModel, checkHistoryCompactCheckpointCurrency, isHistoryCompactContentEvent, matchHistoryCompactCheckpointPrefix, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
 import { HistoryCompactSummarizerError, isMalformedHistoryCompactSummaryReason, } from './history-compact-error.js';
 import { archiveToolResultAsTransition, collectToolResultArchiveCandidates, serializedToolResultProjection, } from './tool-result-archive-transition.js';
 import { estimateTokens, sha256 } from './context-budget-helpers.js';
@@ -140,6 +139,9 @@ export class AiSdkCompaction {
                 // The current durable RuntimeEvents remain sufficient for a fresh checkpoint.
             }
             if (previousCheckpoint) {
+                // Load the transition view only when the raw prefix can replay at all:
+                // a checkpoint that cannot match never reaches for the ledger, the
+                // same as before (#5930 keeps the load point, not the check).
                 const match = matchHistoryCompactCheckpointPrefix(previousCheckpoint, runtimeContext);
                 if (!match.reason && match.successorRuntimeEvents.length === 0) {
                     // Raw identity is not enough: a projection transition committed
@@ -148,9 +150,9 @@ export class AiSdkCompaction {
                     // digest to still match — the same gate the pre-send path applies
                     // (#5929). On drift, fall through to the planner, whose roll-forward
                     // currency check discards the stale checkpoint and re-summarizes.
-                    const effectiveCovered = await this.foldEffectiveModelHistory(match.coveredRuntimeEvents);
-                    if (this.checkpointEffectiveCoverageMatches(previousCheckpoint, effectiveCovered)) {
-                        const projectedEvents = projectHistoryCompactCheckpointReplay(previousCheckpoint, match.coveredRuntimeEvents, []);
+                    const currency = checkHistoryCompactCheckpointCurrency(previousCheckpoint, runtimeContext, await this.loadModelProjectionTransitions());
+                    if (currency.status === 'current') {
+                        const projectedEvents = projectHistoryCompactCheckpointReplay(previousCheckpoint, currency.match.coveredRuntimeEvents, []);
                         return {
                             outcome: { kind: 'unchanged', reason: 'already_compacted' },
                             contextBudget: mergeContextBudgetDiagnostic(buildContextBudgetDiagnosticShell(runtimeContext, projectedEvents, policy), {
@@ -198,11 +200,11 @@ export class AiSdkCompaction {
                     : {}),
                 ...(automaticMemoryBoundary ? { memoryExtractionBoundary: automaticMemoryBoundary } : {}),
                 ...(previousCheckpoint ? { previousCheckpoint } : {}),
-                // The planner projects the covered span to its effective view before
+                // The planner folds the covered span through this snapshot before
                 // summarizing and pins its digest as coverage.effectiveSourceDigest:
                 // the summary can never quote a body a durable transition removed, and
                 // a later transition invalidates the checkpoint at replay (#4845).
-                projectEffectiveCoverage: (covered) => this.foldEffectiveModelHistory(covered),
+                loadProjectionSnapshot: () => this.loadModelProjectionTransitions(),
                 summarize: async ({ coveredRuntimeEvents, newlyFoldedRuntimeEvents, previousCheckpoint, }) => {
                     return await this.summarizeWithFailureCircuit(summarizer, {
                         sessionId: this.sessionId,
@@ -363,27 +365,6 @@ export class AiSdkCompaction {
         return reduceEffectiveModelProjections(events, loaded.transitions, loaded.unreadableTargets)
             .events;
     }
-    /**
-     * Whether the checkpoint's pinned effective view still is the covered
-     * prefix's effective view. The raw identity match happens later in the
-     * replay authority; this gate is about content currency: a projection
-     * transition committed after the fold changes what the model may see of the
-     * covered span without touching the raw ledger, and the checkpoint's summary
-     * or provider state must not survive that drift (#4845 review).
-     */
-    checkpointEffectiveCoverageMatches(checkpoint, effectiveEvents) {
-        const pinned = checkpoint.coverage.effectiveSourceDigest;
-        if (pinned === undefined)
-            return false;
-        const covered = effectiveEvents
-            .filter(isHistoryCompactContentEvent)
-            .slice(0, checkpoint.coverage.eventCount);
-        if (covered.length !== checkpoint.coverage.eventCount)
-            return false;
-        if (covered.at(-1)?.id !== checkpoint.coverage.through.runtimeEventId)
-            return false;
-        return historyCompactSourceDigest(covered) === pinned;
-    }
     /**
      * Apply the same bounded-result rule to current and prior events.
      *
@@ -471,14 +452,8 @@ export class AiSdkCompaction {
             // This gate is only for the case where the raw identity matches but a
             // projection transition committed after the fold changed the effective
             // view the summary (or provider state) was built from (#4845 review).
-            const rawIdentityMatch = matchHistoryCompactCheckpointPrefix(loadedCheckpoint, runtimeContext.filter(isHistoryCompactContentEvent));
-            if (rawIdentityMatch.reason) {
-                nextPolicy = {
-                    ...nextPolicy,
-                    historyCompact: { ...nextPolicy.historyCompact, checkpoint: loadedCheckpoint },
-                };
-            }
-            else if (this.checkpointEffectiveCoverageMatches(loadedCheckpoint, effective.events)) {
+            const currency = checkHistoryCompactCheckpointCurrency(loadedCheckpoint, runtimeContext.filter(isHistoryCompactContentEvent), prepared.projectionSnapshot);
+            if (currency.status !== 'effective_history_changed') {
                 nextPolicy = {
                     ...nextPolicy,
                     historyCompact: { ...nextPolicy.historyCompact, checkpoint: loadedCheckpoint },
@@ -801,7 +776,7 @@ export class AiSdkCompaction {
                     },
                 }
                 : {}),
-            projectEffectiveCoverage: (covered) => this.foldEffectiveModelHistory(covered),
+            loadProjectionSnapshot: () => this.loadModelProjectionTransitions(),
             summarize: async ({ coveredRuntimeEvents, newlyFoldedRuntimeEvents, previousCheckpoint }) => {
                 // Same contract as the standalone path: the planner hands the
                 // effective (transition-folded) view to the summarizer and pins its

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

@@ -46,8 +46,7 @@ import { renderSwarmModePrompt } from './swarm-mode.js';
 import { renderGraphModePrompt } from './graph-mode.js';
 import { modelUsesNativeOpenAiResponses } from './model-runtime.js';
 import { applyRuntimeEventContextBudget, buildContextBudgetDiagnosticShell, mergeContextBudgetDiagnostic, addToolResultPruneStats, minimalContextBudgetDiagnostic, shouldAppendContextCompactedNote, shouldAppendContextCompactionFailedOpenNote, } from './context-budget.js';
-import { isHistoryCompactContentEvent } from './history-compaction.js';
-import { canContinueHistoryCompactCheckpointForModel, historyCompactSourceDigest, isProviderHistoryCompactCheckpoint, matchHistoryCompactCheckpointPrefix, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
+import { canContinueHistoryCompactCheckpointForModel, checkHistoryCompactCheckpointCurrency, isHistoryCompactContentEvent, isProviderHistoryCompactCheckpoint, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
 import { resolveSelectedModelContextWindow } from './context-budget-policy.js';
 import { INVALID_TOOL_NAME, isProviderSandboxBoundaryAttempt, repairMakaToolCall, } from './ai-sdk-tool-repair.js';
 const CHILD_STEP_BUDGET_FINALIZATION_PROMPT = [
@@ -1044,23 +1043,20 @@ export class AiSdkTurn {
                     let replayEvents = rawProjectionEvents;
                     let effectiveProjectionCheckpoint = projectionCheckpoint;
                     if (projectionCheckpoint) {
-                        const checkpointMatch = matchHistoryCompactCheckpointPrefix(projectionCheckpoint, rawProjectionEvents);
-                        if (checkpointMatch.reason) {
-                            throw new Error(`durable checkpoint projection mismatch: ${checkpointMatch.reason}`);
+                        const currency = checkHistoryCompactCheckpointCurrency(projectionCheckpoint, rawProjectionEvents, pruned.projectionSnapshot);
+                        if (currency.status === 'raw_mismatch') {
+                            throw new Error(`durable checkpoint projection mismatch: ${currency.reason}`);
                         }
                         // Content-currency guard: the raw identity still matches, but a
                         // transition committed after this fold (e.g. an active-turn prune
                         // in this very send) changed the effective view the block was
                         // built from. Replay without the stale block — the provider
                         // decides fit and overflow recovery re-folds (#4845 review).
-                        const pinnedEffectiveDigest = projectionCheckpoint.coverage.effectiveSourceDigest;
-                        const coveredEffective = await this.deps.compaction.foldEffectiveModelHistory(checkpointMatch.coveredRuntimeEvents, pruned.projectionSnapshot);
-                        if (pinnedEffectiveDigest === undefined ||
-                            historyCompactSourceDigest(coveredEffective) !== pinnedEffectiveDigest) {
+                        if (currency.status === 'effective_history_changed') {
                             effectiveProjectionCheckpoint = undefined;
                         }
                         else {
-                            replayEvents = projectHistoryCompactCheckpointReplay(projectionCheckpoint, checkpointMatch.coveredRuntimeEvents, checkpointMatch.successorRuntimeEvents);
+                            replayEvents = projectHistoryCompactCheckpointReplay(projectionCheckpoint, currency.match.coveredRuntimeEvents, currency.match.successorRuntimeEvents);
                         }
                         // The checkpoint was capacity-validated before it was persisted.
                         // Do not re-run that gate against a later, larger successor tail:

package/node_modules/@maka/runtime/dist/conversation-copy.js

@@ -25,9 +25,8 @@ import { isEmittedAgentRunEventType } from '@maka/core/agent-run';
 import { decodeModelCallAttempt, MODEL_CALL_ATTEMPT_EVENT_TYPE, } from '@maka/core/model-call-attempt';
 import { TOOL_RECOVERY_DECISION_FACT_KIND } from '@maka/core/tool-recovery-fact';
 import { canonicalToolArgsHash } from '@maka/core/tool-args-identity';
-import { buildHistoryCompactCheckpoint, historyCompactSourceDigest, matchHistoryCompactCheckpointPrefix, validateHistoryCompactCheckpointShape, } from './history-compact-checkpoint.js';
+import { buildHistoryCompactCheckpoint, checkHistoryCompactCheckpointCurrency, isHistoryCompactContentEvent, validateHistoryCompactCheckpointShape, } from './history-compact-checkpoint.js';
 import { findCheckpointSummaryDefect } from './history-compact-summary-validation.js';
-import { isHistoryCompactContentEvent } from './history-compaction.js';
 import { classifyTerminalRuntimeLedger, commitTerminalRunWithRuntimeFact, } from './terminal-run-commit.js';
 import { buildToolOperationId } from './runtime-commit-sink.js';
 import { isContinuationStartRuntimeEvent } from './runtime-event-read-model.js';
@@ -842,13 +841,15 @@ function cloneAgentRunEvent(event, ids, references, sourceCompactableEvents, clo
             return null;
         if (sourceCheckpoint.version === 3)
             return null;
-        const match = matchHistoryCompactCheckpointPrefix(sourceCheckpoint, sourceCompactableEvents);
-        if (match.reason)
-            return null;
-        // Rebinding a digest must not make an already stale source summary valid.
-        const sourceEffective = reduceEffectiveModelProjections(match.coveredRuntimeEvents, [...clonedTransitions.keys()].map((record) => decodeModelProjectionTransition(record.data?.transition, record.sessionId))).events;
-        if (sourceCheckpoint.coverage.effectiveSourceDigest !==
-            historyCompactSourceDigest(sourceEffective))
+        // Rebinding a digest must not make an already stale source summary valid:
+        // the currency check covers the raw prefix match too, so a prefix that no
+        // longer matches is dropped here as well.
+        const currency = checkHistoryCompactCheckpointCurrency(sourceCheckpoint, sourceCompactableEvents, {
+            transitions: [...clonedTransitions.keys()].map((record) => decodeModelProjectionTransition(record.data?.transition, record.sessionId)),
+            unreadableTargets: new Set(),
+            unscopedUnreadable: 0,
+        });
+        if (currency.status !== 'current')
             return null;
         // Copy is an admission seam for the sectioned summary contract: a marked
         // checkpoint whose summary no longer satisfies the COMPLETE predicate —
@@ -858,7 +859,7 @@ function cloneAgentRunEvent(event, ids, references, sourceCompactableEvents, clo
         if (findCheckpointSummaryDefect(sourceCheckpoint.summary) !== undefined) {
             throw new Error(`Cannot copy invalid history compact checkpoint ${event.id}`);
         }
-        const coveredRuntimeEvents = match.coveredRuntimeEvents.map((sourceEvent) => {
+        const coveredRuntimeEvents = currency.match.coveredRuntimeEvents.map((sourceEvent) => {
             const cloned = clonedRuntimeEvents.get(sourceEvent.id);
             if (!cloned) {
                 throw new Error(`History compact checkpoint ${event.id} crosses the conversation copy boundary`);

package/node_modules/@maka/runtime/dist/history-compact-checkpoint.js

@@ -19,6 +19,8 @@
 import { createHash } from 'node:crypto';
 import { Buffer } from 'node:buffer';
 import { nonEmpty, sha256 } from './context-budget-helpers.js';
+import { estimateRuntimeEventChars } from './model-history.js';
+import { reduceEffectiveModelProjections, } from './model-projection-transition-ledger.js';
 import { stableStringify } from './request-shape.js';
 import { findCheckpointSummaryDefect, SECTIONED_SUMMARY_FORMAT, } from './history-compact-summary-validation.js';
 // v3: coverage identity and the source digest stay pinned on the RAW ledger
@@ -399,6 +401,29 @@ export function matchHistoryCompactCheckpointPrefix(checkpoint, events) {
         successorRuntimeEvents,
     };
 }
+/**
+ * Judges a checkpoint against `events` under `projectionSnapshot` — the SAME
+ * loaded transition view the caller used to build the request being judged.
+ * The function never loads transitions: a checkpoint is only current for the
+ * snapshot it is checked with, and a record committed after that snapshot
+ * belongs to the next request's decision.
+ */
+export function checkHistoryCompactCheckpointCurrency(checkpoint, events, projectionSnapshot) {
+    const match = matchHistoryCompactCheckpointPrefix(checkpoint, events);
+    if (match.reason !== undefined) {
+        return { status: 'raw_mismatch', reason: match.reason };
+    }
+    const effectiveCovered = reduceEffectiveModelProjections(match.coveredRuntimeEvents, projectionSnapshot.transitions, projectionSnapshot.unreadableTargets).events.filter(isHistoryCompactContentEvent);
+    const pinned = checkpoint.coverage.effectiveSourceDigest;
+    if (pinned === undefined ||
+        effectiveCovered.length < checkpoint.coverage.eventCount ||
+        effectiveCovered[checkpoint.coverage.eventCount - 1]?.id !==
+            checkpoint.coverage.through.runtimeEventId ||
+        historyCompactSourceDigest(effectiveCovered.slice(0, checkpoint.coverage.eventCount)) !== pinned) {
+        return { status: 'effective_history_changed' };
+    }
+    return { status: 'current', match };
+}
 /**
  * Deterministic RuntimeEvent projection for a checkpoint. V2 prepends its
  * text block; V3 stays out of the event list and is materialized directly at
@@ -516,6 +541,10 @@ function effectiveDigestEvent(event) {
     }
     return { ...event, content: { ...identity, result } };
 }
+/** True when the event carries model-visible content the compact projection counts. */
+export function isHistoryCompactContentEvent(event) {
+    return event.modelVisibility !== 'hidden' && estimateRuntimeEventChars(event) > 0;
+}
 function validHistoryCompactProviderState(value) {
     if (!value || typeof value !== 'object')
         return false;

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

@@ -16,11 +16,12 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { estimateRuntimeEventChars, estimateRuntimeEventsTokens } from './model-history.js';
+import { estimateRuntimeEventsTokens } from './model-history.js';
 import { compactionDecisionDiagnosticPatch } from './compaction-boundary.js';
 import { HistoryCompactSummarizerError, } from './history-compact-error.js';
 import { findCheckpointSummaryDefect } from './history-compact-summary-validation.js';
-import { buildHistoryCompactCheckpoint, historyCompactCheckpointToRuntimeEvent, historyCompactSourceDigest, matchHistoryCompactCheckpointPrefix, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
+import { buildHistoryCompactCheckpoint, checkHistoryCompactCheckpointCurrency, historyCompactCheckpointToRuntimeEvent, isHistoryCompactContentEvent, matchHistoryCompactCheckpointPrefix, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
+import { reduceEffectiveModelProjections, } from './model-projection-transition-ledger.js';
 /**
  * Select the largest contiguous covered prefix that is safe to fold:
  *
@@ -180,12 +181,14 @@ export async function planHistoryCompaction(input) {
             return noSafeSpan();
         const coveredRuntimeEvents = input.orderedEvents.slice(0, boundary.coveredCount);
         const tailRuntimeEvents = input.orderedEvents.slice(boundary.coveredCount);
+        // One transition view per pass: the same loaded snapshot judges the
+        // previous checkpoint's currency and produces the effective view the
+        // summary is written from.
+        const projectionSnapshot = input.loadProjectionSnapshot
+            ? await input.loadProjectionSnapshot()
+            : undefined;
         // Roll forward from a previous checkpoint when it is an exact prefix of the
         // covered events, so the summary only re-reads the newly folded span.
-        const checkpointMatch = input.previousCheckpoint
-            ? matchHistoryCompactCheckpointPrefix(input.previousCheckpoint, coveredRuntimeEvents)
-            : undefined;
-        let previousCheckpoint = checkpointMatch && !checkpointMatch.reason ? input.previousCheckpoint : undefined;
         // Content-currency gate for roll-forward: the inherited summary or
         // provider state describes the EFFECTIVE view of the previous coverage at
         // its own creation. A projection transition committed since rewrites that
@@ -193,20 +196,31 @@ export async function planHistoryCompaction(input) {
         // would launder it into the new checkpoint under the current effective
         // digest — later replay guards would then pass it (#4845 review). On
         // drift, discard the checkpoint and re-summarize the whole effective span.
-        if (previousCheckpoint && checkpointMatch && input.projectEffectiveCoverage) {
-            const pinned = previousCheckpoint.coverage.effectiveSourceDigest;
-            const previousEffectiveCovered = await input.projectEffectiveCoverage(checkpointMatch.coveredRuntimeEvents);
-            if (pinned === undefined || historyCompactSourceDigest(previousEffectiveCovered) !== pinned) {
+        let previousCheckpoint = input.previousCheckpoint;
+        let successorRuntimeEvents;
+        if (previousCheckpoint && projectionSnapshot) {
+            const currency = checkHistoryCompactCheckpointCurrency(previousCheckpoint, coveredRuntimeEvents, projectionSnapshot);
+            if (currency.status === 'current') {
+                successorRuntimeEvents = currency.match.successorRuntimeEvents;
+            }
+            else {
+                previousCheckpoint = undefined;
+            }
+        }
+        else if (previousCheckpoint) {
+            const match = matchHistoryCompactCheckpointPrefix(previousCheckpoint, coveredRuntimeEvents);
+            if (match.reason === undefined) {
+                successorRuntimeEvents = match.successorRuntimeEvents;
+            }
+            else {
                 previousCheckpoint = undefined;
             }
         }
-        const newlyFoldedRuntimeEvents = previousCheckpoint
-            ? checkpointMatch.successorRuntimeEvents
-            : coveredRuntimeEvents;
+        const newlyFoldedRuntimeEvents = successorRuntimeEvents ?? coveredRuntimeEvents;
         // The model-visible summary reads the effective (transition-folded) view
         // of the covered span; the raw events keep the coverage identity.
-        const effectiveCoveredRuntimeEvents = input.projectEffectiveCoverage
-            ? [...(await input.projectEffectiveCoverage(coveredRuntimeEvents))]
+        const effectiveCoveredRuntimeEvents = projectionSnapshot
+            ? reduceEffectiveModelProjections(coveredRuntimeEvents, projectionSnapshot.transitions, projectionSnapshot.unreadableTargets).events
             : undefined;
         const effectiveNewlyFoldedRuntimeEvents = effectiveCoveredRuntimeEvents
             ? newlyFoldedRuntimeEvents.length === coveredRuntimeEvents.length
@@ -350,7 +364,3 @@ export function applyRuntimeEventHistoryCompact(events, policy, charsPerToken =
         }),
     };
 }
-/** True when the event carries model-visible content the compact projection counts. */
-export function isHistoryCompactContentEvent(event) {
-    return event.modelVisibility !== 'hidden' && estimateRuntimeEventChars(event) > 0;
-}

package/node_modules/@maka/runtime/dist/memory-extraction.js

@@ -21,8 +21,7 @@ import { redactSecrets } from '@maka/core/redaction';
 import { z } from 'zod';
 import { fitMemoryExtractionEvidence, bindProviderVisibleEvidence, isMemoryToolName, planMemoryCoverage, projectMemoryExtractionEvidence, renderMemoryLocalizationContext, searchSameSessionMemoryHistory, } from './memory-extraction-evidence.js';
 import { admitMemoryProposalItemDetailed, buildFirstMemoryProposalPrompt, buildLocalizedMemoryProposalPrompt, buildMemoryCanonicalizationPrompt, deterministicMemoryPolicyRejection, minuteTimestamp, parseMemoryCanonicalization, parseLocalizedMemoryProposal, parseMemoryProposal, } from './memory-extraction-proposal.js';
-import { isHistoryCompactContentEvent } from './history-compaction.js';
-import { isTextHistoryCompactCheckpoint, matchHistoryCompactCheckpointPrefix, renderHistoryCompactCheckpoint, } from './history-compact-checkpoint.js';
+import { isHistoryCompactContentEvent, isTextHistoryCompactCheckpoint, matchHistoryCompactCheckpointPrefix, renderHistoryCompactCheckpoint, } from './history-compact-checkpoint.js';
 import { applyRuntimeEventProviderHistoryBoundary } from './model-history.js';
 export const MEMORY_REMEMBER_TOOL_NAME = 'memory_remember';
 export const MEMORY_EXTRACT_TOOL_NAME = 'memory_extract';

package/node_modules/@maka/runtime/dist/plugin-executor-backend.js

@@ -59,8 +59,8 @@ export class PluginExecutorBackend {
                 yield event;
                 queue.ackConsumed();
             }
-            const returnedResult = await producer;
-            if (returnedResult) {
+            const settlement = await producer;
+            if (settlement === 'published') {
                 // The Runtime Kernel requests the next item only after onSessionEvent
                 // resolves. Reaching this point means its terminal event was accepted.
                 // The Plugin decides whether its external execution actually settled;
@@ -78,8 +78,11 @@ export class PluginExecutorBackend {
         finally {
             queue.noteConsumerDetached();
             abort.abort(new Error('Plugin executor event consumer detached'));
-            const returnedResult = await producer.catch(() => false);
-            if (returnedResult &&
+            // A settled result that was not acknowledged is abandoned, including one
+            // the Runtime rejected before publishing it. A provider failure before
+            // settlement is neither acknowledged nor abandoned.
+            const settlement = await producer.catch(() => 'unsettled');
+            if (settlement !== 'unsettled' &&
                 this.#binding.acknowledgeExecution &&
                 !acknowledged &&
                 this.#binding.abandonExecution)
@@ -113,6 +116,7 @@ export class PluginExecutorBackend {
         let result;
         let failure;
         let failed = false;
+        let settled = false;
         try {
             result = await this.#binding.execute({
                 sessionId: this.sessionId,
@@ -130,6 +134,9 @@ export class PluginExecutorBackend {
                 ...(input.quotes ? { quotes: input.quotes } : {}),
             }, {
                 signal,
+                onSettled: () => {
+                    settled = true;
+                },
                 onEvent: (event) => {
                     if (event.type === 'thinking_delta')
                         thinkingText += event.text;
@@ -148,14 +155,14 @@ export class PluginExecutorBackend {
                 this.#publishCancellation(turnId, { status: 'cancelled', source: 'caller' }, queue);
             else
                 this.#publishFailure(turnId, failure instanceof Error ? failure.message : 'External executor failed', undefined, false, queue);
-            return false;
+            return settled ? 'rejected' : 'unsettled';
         }
         if (result === undefined) {
             this.#publishFailure(turnId, 'External executor returned no terminal result', undefined, false, queue);
-            return false;
+            return settled ? 'rejected' : 'unsettled';
         }
         this.#publishResult(turnId, messageId, result, queue);
-        return true;
+        return 'published';
     }
     async #requestPermission(input, request, signal, toolUseIds, queue) {
         const hosted = input.hostedInteraction;

package/node_modules/@maka/runtime/dist/plugin-executor-service.js

@@ -280,6 +280,12 @@ export class PluginExecutorService extends Service {
                         return normalizePermissionResult(result, normalized);
                     },
                 });
+                try {
+                    options.onSettled?.();
+                }
+                catch {
+                    // A settlement observer must not change external execution.
+                }
                 if (signal.aborted) {
                     const cancelled = cancelledResult(signal.reason);
                     const normalized = normalizeResult(result);