You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maka.apache.org by as...@apache.org on 2026/08/24 14:42:53 UTC

(maka) 01/01: fix(runtime): keep atomic message transcripts recovery-safe

This is an automated email from the ASF dual-hosted git repository.

Astro-Han pushed a commit to branch fix/durable-message-lifecycle
in repository https://gitbox.apache.org/repos/asf/maka.git

commit 6347ca75ba8b965e0606d34ded719677a70d58e7
Author: AstroHan <le...@outlook.com>
AuthorDate: Mon Aug 24 22:42:41 2026 +0800

    fix(runtime): keep atomic message transcripts recovery-safe
    
    Preserve live Client capability bindings, make cancellation retries idempotent, and keep admission-backed transcripts out of compatibility Run synthesis until their root contract owns them.
    
    Generated-by: Codex
---
 .../src/server/client-capability-coordinator.ts       |  5 +++++
 .../src/server/hosted-execution-recovery.ts           |  2 +-
 .../runtime-host/src/server/root-turn-coordinator.ts  |  4 +++-
 packages/runtime/src/runtime-ledger-repair.ts         | 19 +++++++++++++++++--
 packages/runtime/src/session-manager.ts               | 11 +++++++++++
 packages/storage/src/sqlite-session-metadata-store.ts | 13 ++++++++++---
 6 files changed, 47 insertions(+), 7 deletions(-)

diff --git a/packages/runtime-host/src/server/client-capability-coordinator.ts b/packages/runtime-host/src/server/client-capability-coordinator.ts
index 5841132bb..09e18cd56 100644
--- a/packages/runtime-host/src/server/client-capability-coordinator.ts
+++ b/packages/runtime-host/src/server/client-capability-coordinator.ts
@@ -249,6 +249,11 @@ export class HostClientCapabilityCoordinator implements ClientCapabilityService
     execution: RootExecutionDescriptor;
   }): Promise<void> {
     if (input.execution.kind !== 'external_message' || input.userMessageId === null) return;
+    // A live root already selected its Client capabilities at admission. Only
+    // cold recovery needs to rebuild a missing in-memory binding from the
+    // durable root contract; reselecting here would discard the active
+    // connection/turn-affine binding and can make providers ambiguous.
+    if (this.#sessions.has(input.sessionId)) return;
     await this.#activation.runMutation(async () => {
       const selection = this.#selectSessionState(input.sessionId, '', 'degrade');
       if (!selection.ok) throw new Error(selection.message);
diff --git a/packages/runtime-host/src/server/hosted-execution-recovery.ts b/packages/runtime-host/src/server/hosted-execution-recovery.ts
index 5187583b1..674c92e2d 100644
--- a/packages/runtime-host/src/server/hosted-execution-recovery.ts
+++ b/packages/runtime-host/src/server/hosted-execution-recovery.ts
@@ -69,7 +69,7 @@ export async function prepareHostedExecutionRecovery(
       const run = runsById.get(admission.runId);
       const rootUserMessages = (
         messageIndex.userMessagesByTurnId.get(admission.turnId) ?? []
-      ).filter((message) => message.steeringEventId === undefined);
+      ).filter((message) => message.id === admission.userMessageId);
       const messageIdOwners = admission.userMessageId
         ? (messageIndex.messagesById.get(admission.userMessageId) ?? [])
         : [];
diff --git a/packages/runtime-host/src/server/root-turn-coordinator.ts b/packages/runtime-host/src/server/root-turn-coordinator.ts
index fd3441695..9dd00b692 100644
--- a/packages/runtime-host/src/server/root-turn-coordinator.ts
+++ b/packages/runtime-host/src/server/root-turn-coordinator.ts
@@ -1984,7 +1984,9 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
       userMessageId: admission.userMessageId,
       execution: admission.execution,
     });
-    const initialUserMessagesMaterialized = admission.sourceMessages.length > 0;
+    const initialUserMessagesMaterialized =
+      admission.sourceMessages.length > 0 &&
+      admission.sourceMessages.every((source) => source.disposition === 'turn_started');
     if (initialUserMessagesMaterialized) {
       await this.manager.materializeRootSourceMessages({
         sessionId: input.sessionId,
diff --git a/packages/runtime/src/runtime-ledger-repair.ts b/packages/runtime/src/runtime-ledger-repair.ts
index 98e85f410..6071b73d0 100644
--- a/packages/runtime/src/runtime-ledger-repair.ts
+++ b/packages/runtime/src/runtime-ledger-repair.ts
@@ -38,6 +38,8 @@ export interface RuntimeLedgerRepairDeps {
   runStore: AgentRunStore;
   runtimeEventStore: RuntimeEventStore;
   readMessages(sessionId: string): Promise<StoredMessage[]>;
+  readPendingMessageIds?(sessionId: string): Promise<readonly string[]>;
+  readMessageLifecycleState?(sessionId: string, messageId: string): Promise<string | undefined>;
   appendMessage(sessionId: string, message: StoredMessage): Promise<void>;
   appendTurnState(
     sessionId: string,
@@ -89,11 +91,24 @@ export class RuntimeLedgerRepair {
         this.deps.readMessages(sessionId),
         this.deps.runStore.listSessionRuns(sessionId),
       ]);
+      const pendingMessageIds = new Set((await this.deps.readPendingMessageIds?.(sessionId)) ?? []);
+      if (this.deps.readMessageLifecycleState) {
+        const lifecycleStates = await Promise.all(
+          messages.map(async (message) => ({
+            messageId: message.id,
+            state: await this.deps.readMessageLifecycleState!(sessionId, message.id),
+          })),
+        );
+        for (const { messageId, state } of lifecycleStates) {
+          if (state !== undefined) pendingMessageIds.add(messageId);
+        }
+      }
+      const ledgerMessages = messages.filter((message) => !pendingMessageIds.has(message.id));
       const inlineRunsByTurn = new Map(
         runs.filter(isSessionInlineRun).map((run) => [run.turnId, run] as const),
       );
-      const messagesByTurn = groupMessagesByTurn(messages);
-      const turns = deriveTurnRecords(messages).filter((turn) =>
+      const messagesByTurn = groupMessagesByTurn(ledgerMessages);
+      const turns = deriveTurnRecords(ledgerMessages).filter((turn) =>
         (messagesByTurn.get(turn.turnId) ?? []).some((message) => message.type === 'user'),
       );
       if (turns.length === 0) return;
diff --git a/packages/runtime/src/session-manager.ts b/packages/runtime/src/session-manager.ts
index df5977718..b556f87db 100644
--- a/packages/runtime/src/session-manager.ts
+++ b/packages/runtime/src/session-manager.ts
@@ -672,6 +672,11 @@ export interface SessionStore {
   list(filter?: SessionListFilter): Promise<SessionSummary[]>;
   readHeader(sessionId: string): Promise<SessionHeader>;
   readMessages(sessionId: string): Promise<StoredMessage[]>;
+  listMessageAdmissions?(sessionId: string): Promise<readonly { messageId: string }[]>;
+  readMessageLifecycleState?(
+    sessionId: string,
+    messageId: string,
+  ): Promise<'accepted' | 'handed_off' | 'executed' | 'cancelled' | undefined>;
   readMessagesSnapshot?(sessionId: string): Promise<StoredMessage[]>;
   listTurns(sessionId: string): Promise<TurnRecord[]>;
   appendMessage(sessionId: string, m: StoredMessage): Promise<void>;
@@ -941,6 +946,12 @@ export class SessionManager {
         runStore: deps.runStore,
         runtimeEventStore: deps.runtimeEventStore,
         readMessages: (sessionId) => deps.store.readMessages(sessionId),
+        readPendingMessageIds: async (sessionId) =>
+          (await deps.store.listMessageAdmissions?.(sessionId))?.map(
+            ({ messageId }) => messageId,
+          ) ?? [],
+        readMessageLifecycleState: async (sessionId, messageId) =>
+          deps.store.readMessageLifecycleState?.(sessionId, messageId) ?? undefined,
         appendMessage: (sessionId, message) => deps.store.appendMessage(sessionId, message),
         appendTurnState: (sessionId, turnId, status, lineage, options) =>
           this.appendTurnState(sessionId, turnId, status, lineage, options),
diff --git a/packages/storage/src/sqlite-session-metadata-store.ts b/packages/storage/src/sqlite-session-metadata-store.ts
index 29f8d77ed..6fc0e5932 100644
--- a/packages/storage/src/sqlite-session-metadata-store.ts
+++ b/packages/storage/src/sqlite-session-metadata-store.ts
@@ -1842,9 +1842,16 @@ export class SqliteSessionMetadataStore {
       for (const messageId of unique) {
         const result = statement.run(sessionId, messageId);
         if (result.changes !== 1) {
-          throw new SessionMetadataConflictError(
-            'Message admission cancellation identity conflict',
-          );
+          const existing = this.db
+            .prepare(
+              'SELECT lifecycle_state FROM message_admissions WHERE session_id = ? AND message_id = ?',
+            )
+            .get(sessionId, messageId) as { lifecycle_state?: unknown } | undefined;
+          if (existing?.lifecycle_state !== 'cancelled') {
+            throw new SessionMetadataConflictError(
+              'Message admission cancellation identity conflict',
+            );
+          }
         }
       }
     });


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@maka.apache.org
For additional commands, e-mail: commits-help@maka.apache.org