maka-agent 0.2.0-dev.22.20260905 → 0.2.0-dev.23.20260906

package/node_modules/@maka/runtime-host/dist/protocol/workhub-coordination.js

@@ -274,6 +274,27 @@ export function decodeWorkHubCoordinationActResult(value) {
                 }),
         };
     }
+    if (result.disposition === 'resume_work') {
+        const exact = requireShapedRecord(result, 'WorkHub Coordination resume result', ['disposition', 'outcome', 'targetSessionId'], ['targetTurnId']);
+        if (exact.outcome !== 'resume_started' && exact.outcome !== 'already_running') {
+            throw invalidProtocolFrame('Invalid WorkHub resume outcome');
+        }
+        // Only a started continuation names a Turn: the Host has one to name, and
+        // the other two outcomes changed nothing that could carry an identity.
+        if ((exact.outcome === 'resume_started') !== (exact.targetTurnId !== undefined)) {
+            throw invalidProtocolFrame('Invalid WorkHub resume target Turn');
+        }
+        return {
+            disposition: 'resume_work',
+            outcome: exact.outcome,
+            targetSessionId: requireEntityId(exact.targetSessionId, 'WorkHub target Session id'),
+            ...(exact.targetTurnId === undefined
+                ? {}
+                : {
+                    targetTurnId: requireEntityId(exact.targetTurnId, 'WorkHub target Turn id'),
+                }),
+        };
+    }
     throw invalidProtocolFrame('Invalid WorkHub Coordination action disposition');
 }
 function decodeWorkHubCoordinationCandidate(value) {
@@ -372,6 +393,18 @@ function decodeWorkHubCoordinationProposal(value) {
             expects: decodeWorkHubCoordinationStopPreconditions(exact.expects),
         };
     }
+    if (proposal.disposition === 'resume_work') {
+        const exact = requireExactRecord(proposal, 'WorkHub resume proposal', [
+            'disposition',
+            'expects',
+            'resumesActionId',
+        ]);
+        return {
+            disposition: 'resume_work',
+            resumesActionId: requireEntityId(exact.resumesActionId, 'WorkHub resume assignment'),
+            expects: decodeWorkHubCoordinationStopPreconditions(exact.expects),
+        };
+    }
     throw invalidProtocolFrame('Invalid WorkHub Coordination proposal disposition');
 }
 function decodeWorkHubCoordinationStopPreconditions(value) {

package/node_modules/@maka/runtime-host/dist/server/access-authority.js

@@ -20,7 +20,7 @@ import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { join } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { runtimeHostAccessCredentialHash } from '../access-credential-identity.js';
-import { encodeCollaborationInvitationCode, } from '../protocol/index.js';
+import { decodeCollaborationDisplayName, encodeCollaborationInvitationCode, } from '../protocol/index.js';
 import { createRuntimeHostConnectionAuthority, } from './connection-authority.js';
 import { createAccessCredentialDelivery, discardAccessCredentialDelivery, purgeAccessCredentialDeliveries, } from '../control/access-credential-delivery.js';
 import { ACCESS_FILE_NAME, assertAccessCredentialFileCapacity, CAPABILITY_PROVIDER_OPERATION_GRANTS, createAccessCredentialFile, effectiveOperationGrants, issuedAccessGrants, readAccessCredentialFile, RuntimeHostAccessCommitOutcomeUnknownError, RuntimeHostAccessInputError, SESSION_GUEST_OPERATION_GRANTS, writeAccessCredentialFile, } from './access-credential-store.js';
@@ -152,6 +152,9 @@ class FileRuntimeHostAccessAuthority {
                         principalId,
                         status: credential.status,
                         createdAt: credential.createdAt,
+                        ...(credential.displayName === undefined
+                            ? {}
+                            : { displayName: credential.displayName }),
                         ...(credential.expiresAt ? { expiresAt: credential.expiresAt } : {}),
                     },
                 ]
@@ -176,6 +179,18 @@ class FileRuntimeHostAccessAuthority {
             principalId,
         });
     }
+    renameCollaborationPrincipal(input) {
+        const displayName = decodeCollaborationDisplayName(input.displayName);
+        return this.#mutate(async () => {
+            const matches = (credential) => credential.principalKind === 'session_guest' &&
+                credential.principalId === input.principalId &&
+                credential.status !== 'revoked';
+            if (!this.#file.credentials.some(matches))
+                return { renamed: false };
+            await this.#commit(createNextAccessCredentialFile(this.#file, this.#file.credentials.map((credential) => matches(credential) ? { ...credential, displayName } : credential), this.#file.sessionGrants), []);
+            return { renamed: true };
+        });
+    }
     createTurnAccessRequest(principalId, input) {
         return this.#mutate(async () => {
             const grant = this.activeSessionGrant(principalId, input.intent.sessionId, 'session_turn_request');
@@ -960,6 +975,16 @@ export async function revokeCollaborationPrincipal(authority, principalId) {
         return accessPersistenceFailure(error, 'Collaboration Guest revocation outcome is unknown', 'Collaboration Guest could not be revoked');
     }
 }
+export async function renameCollaborationPrincipal(authority, input) {
+    if (!authority)
+        return collaborationUnavailable('collaboration.principal.rename');
+    try {
+        return { ok: true, result: await authority.renameCollaborationPrincipal(input) };
+    }
+    catch (error) {
+        return accessPersistenceFailure(error, 'Guest alias commit outcome is unknown', 'Guest alias could not be saved');
+    }
+}
 function collaborationUnavailable(operation) {
     return {
         ok: false,

package/node_modules/@maka/runtime-host/dist/server/access-credential-store.js

@@ -19,7 +19,7 @@
 import { randomUUID } from 'node:crypto';
 import { chmod, open, rename, rm } from 'node:fs/promises';
 import { dirname } from 'node:path';
-import { HOST_OPERATION_SPECS, operationAllowsRemoteOwner, decodeSessionTurnAccessRequest, } from '../protocol/index.js';
+import { HOST_OPERATION_SPECS, operationAllowsRemoteOwner, decodeSessionTurnAccessRequest, decodeCollaborationDisplayName, } from '../protocol/index.js';
 // Schema 4 makes provider ownership downgrade-safe once an association exists.
 // Ordinary access files remain schema 3 so this feature does not fence a
 // downgrade before there is an owner association to preserve.
@@ -225,6 +225,7 @@ function encodeAccessCredentialFile(file) {
         schemaVersion: file.schemaVersion,
         credentials: file.credentials.map((credential) => ({
             credentialId: credential.credentialId,
+            ...(credential.displayName === undefined ? {} : { displayName: credential.displayName }),
             credentialHash: credential.credentialHash,
             principalId: credential.principalId,
             principalKind: credential.principalKind,
@@ -391,6 +392,9 @@ function decodeStoredCredential(value) {
         ...(typeof clientInstanceId === 'string' ? { clientInstanceId } : {}),
         ...(typeof expiresAt === 'string' ? { expiresAt } : {}),
         ...(revokedAt === undefined ? {} : { revokedAt }),
+        ...(value.displayName === undefined
+            ? {}
+            : { displayName: decodeCollaborationDisplayName(value.displayName) }),
     };
 }
 function decodeStoredSessionGrant(value) {

package/node_modules/@maka/runtime-host/dist/server/canonical-usage-reader.js

@@ -16,33 +16,46 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { resolveUsageRange } from '@maka/core/model-call-usage-projection';
 export class CanonicalUsageProjectionIncompleteError extends Error {
     constructor() {
         super('Canonical Usage projection is incomplete');
         this.name = 'CanonicalUsageProjectionIncompleteError';
     }
 }
-/** Reads and repairs the canonical usage source shared by Host-owned projections. */
-export async function readCanonicalUsage(stores, query, now, repair = true) {
-    // `catchUpModelCallProjection` is a write. Paged log reads call this once per
-    // page, so a caller that already repaired on its first page can pass
-    // `repair: false` on later pages to avoid a redundant repair write per page.
+/**
+ * Repairs the projection, then asks the ledger for one answer.
+ *
+ * `catchUpModelCallProjection` is a write. Paged log reads call this once per
+ * page, so a caller that already repaired on its first page passes
+ * `repair: false` on later pages to avoid a redundant repair write per page.
+ */
+async function readCanonical(stores, query, repair, ask) {
     const repairOutcome = repair
         ? await stores.modelCalls
             .catchUpModelCallProjection(query.sessionId === undefined ? undefined : { sessionId: query.sessionId })
             .catch(() => ({ pendingRuns: 1, unreadableEvents: 0 }))
         : { pendingRuns: 0, unreadableEvents: 0 };
-    const page = await stores.modelCalls.modelCallAttempts(resolveUsageRange(query.range, now), query.sessionId);
+    const answer = await ask();
     return {
-        attempts: page.attempts,
-        unreadableRecords: page.unreadableRecords + repairOutcome.unreadableEvents,
+        projection: answer.projection,
+        unreadableRecords: answer.unreadableRecords + repairOutcome.unreadableEvents,
         pendingRepairs: repairOutcome.pendingRuns,
     };
 }
+export function readCanonicalUsageSummary(stores, query, now, repair = true) {
+    return readCanonical(stores, query, repair, () => stores.modelCalls.modelCallSummary(query, now));
+}
+export function readCanonicalUsageBuckets(stores, query, groupBy, now, repair = true) {
+    return readCanonical(stores, query, repair, () => stores.modelCalls.modelCallBuckets(query, groupBy, now));
+}
+export function readCanonicalUsageLogs(stores, query, now, limit, repair = true) {
+    // Both sources are newest-first, so a merged page can only be drawn from each
+    // source's own first `offset + limit` rows.
+    return readCanonical(stores, query, repair, () => stores.modelCalls.modelCallLogs(query, now, 0, limit));
+}
 /** Runs one bounded repair pass and rejects data still unsafe for durable derivatives. */
-export async function readCompleteCanonicalUsage(stores, query, now) {
-    const source = await readCanonicalUsage(stores, query, now);
+export async function readCompleteCanonicalUsageSummary(stores, query, now) {
+    const source = await readCanonicalUsageSummary(stores, query, now);
     if (source.unreadableRecords > 0 || source.pendingRepairs > 0) {
         throw new CanonicalUsageProjectionIncompleteError();
     }

package/node_modules/@maka/runtime-host/dist/server/daily-review-coordinator.js

@@ -22,7 +22,7 @@ import { mergeUsageBuckets, mergeUsageSummary } from '@maka/core/usage-ledger-me
 import { authenticateInteractiveDailyReviewAuthorityWriter, } from '@maka/storage/daily-review-authority';
 import { authenticateInteractiveUsageStoresWriter, } from '@maka/storage/usage-stores';
 import { DAILY_REVIEW_RESULT_MAX_BYTES, } from '../protocol/index.js';
-import { CanonicalUsageProjectionIncompleteError, readCompleteCanonicalUsage, } from './canonical-usage-reader.js';
+import { CanonicalUsageProjectionIncompleteError, readCanonicalUsageBuckets, readCompleteCanonicalUsageSummary, } from './canonical-usage-reader.js';
 const ARCHIVE_LIMIT = 180;
 const SCHEDULER_INTERVAL_MS = 60_000;
 /** Host-owned Daily Review data, generation, archive, and scheduling boundary. */
@@ -196,7 +196,10 @@ export class HostDailyReviewCoordinator {
     }
     async #buildSummary(range, now) {
         const query = dailyUsageQuery(range);
-        const canonical = await readCompleteCanonicalUsage(this.#usage, query, now);
+        // The summary read repairs the projection and refuses an incomplete one; the
+        // bucket read that follows reuses that pass rather than repairing again.
+        const canonical = await readCompleteCanonicalUsageSummary(this.#usage, query, now);
+        const canonicalModels = await readCanonicalUsageBuckets(this.#usage, query, 'model', now, false);
         const [usageSummary, toolBuckets, modelBuckets, sessions] = await Promise.all([
             this.#usage.telemetry.summary(query),
             this.#usage.telemetry.buckets(query, 'tool'),
@@ -205,10 +208,10 @@ export class HostDailyReviewCoordinator {
         ]);
         return buildDailyReviewSummary({
             day: range,
-            usageSummary: mergeUsageSummary(usageSummary, canonical, query, now),
+            usageSummary: mergeUsageSummary(usageSummary, canonical),
             sessions: pickDailyReviewSessions(collapseSessionRevisions(sessions), range, DAILY_REVIEW_LIST_LIMIT),
             topTools: pickDailyReviewTopEntries(toolBuckets, DAILY_REVIEW_LIST_LIMIT),
-            topModels: pickDailyReviewTopEntries(mergeUsageBuckets(modelBuckets, canonical, query, 'model', now).buckets, DAILY_REVIEW_LIST_LIMIT),
+            topModels: pickDailyReviewTopEntries(mergeUsageBuckets(modelBuckets, canonicalModels).buckets, DAILY_REVIEW_LIST_LIMIT),
         });
     }
     async #run(input) {

package/node_modules/@maka/runtime-host/dist/server/execution-composition.js

@@ -119,7 +119,7 @@ import { HostTurnControlCoordinator } from './turn-control-coordinator.js';
 import { HostUsagePricingCoordinator } from './usage-pricing-coordinator.js';
 import { HostWebSearchCoordinator } from './web-search-coordinator.js';
 import { HostWorkHubCoordinationCoordinator } from './workhub-coordination-coordinator.js';
-import { WorkHubActionEffectFailure } from './workhub-coordination-action-gate.js';
+import { WorkHubActionEffectFailure, workHubResumedTurnId, } from './workhub-coordination-action-gate.js';
 import { createHostWebSearchService, createHostWebSearchToolFromService, resolveHostTavilyWebSearchReadiness, shouldResolveHostTavilyWebSearchReadiness, } from './web-search-tool.js';
 import { createHostWebFetchService, createHostWebFetchToolFromService } from './web-fetch-tool.js';
 import { createHostExecutionArtifactServices } from './execution-artifacts.js';
@@ -391,6 +391,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         let deepResearch;
         let dailyReview;
         const rootPort = {
+            readLatestRootTurnLineage: (identity) => requireRootCoordinator(rootCoordinator).readLatestRootTurnLineage(identity),
             readSessionHeader: (sessionId) => requireRootCoordinator(rootCoordinator).readSessionHeader(sessionId),
             readRootState: (sessionId) => requireRootCoordinator(rootCoordinator).readRootState(sessionId),
             claimStopFence: (input, commitQueueFence, admission) => requireRootCoordinator(rootCoordinator).claimStopFence(input, commitQueueFence, admission),
@@ -1054,13 +1055,76 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                         turnId: disposition.turnId,
                         runId: disposition.runId,
                     };
-                    if (isActiveWorkHubRoot(coordinator, identity))
+                    const latest = await coordinator.readLatestRootTurnLineage(identity);
+                    if (isActiveWorkHubRoot(coordinator, latest))
                         return 'not_retired';
                     // The same restart window as `stopOwnedWorkHubRoot`: an unregistered
                     // root is not evidence that its work ended.
-                    const snapshot = await coordinator.read(identity);
+                    const snapshot = await coordinator.read(latest);
                     return isHostedExecutionTerminal(snapshot) ? 'retired' : 'recovering';
                 },
+                // Resolve and resume only the execution lineage owned by this
+                // delegation. A Session-wide latest-failure query could otherwise
+                // continue unrelated work started directly in the same Session.
+                resumeDelegation: async (assignment, context, actionId) => {
+                    const disposition = await messages.readMessageExecutionDisposition(assignment.targetSessionId, assignment.targetMessageId);
+                    if (disposition.kind === 'recovering') {
+                        throw new WorkHubActionEffectFailure('host_not_ready', 'WorkHub is still recovering the delegated execution');
+                    }
+                    if (disposition.kind !== 'owned_root') {
+                        throw new WorkHubActionEffectFailure('operation_conflict', 'WorkHub delegated execution is not resumable');
+                    }
+                    const source = await coordinator.readLatestRootTurnLineage({
+                        sessionId: assignment.targetSessionId,
+                        turnId: disposition.turnId,
+                        runId: disposition.runId,
+                    });
+                    if (isActiveWorkHubRoot(coordinator, source)) {
+                        return { outcome: 'already_running' };
+                    }
+                    const snapshot = await coordinator.read(source);
+                    if (!isHostedExecutionTerminal(snapshot)) {
+                        throw new WorkHubActionEffectFailure('host_not_ready', 'WorkHub is still recovering the delegated execution');
+                    }
+                    if (snapshot.status !== 'failed' && snapshot.status !== 'cancelled') {
+                        throw new WorkHubActionEffectFailure('operation_conflict', 'WorkHub delegated execution is not resumable');
+                    }
+                    const plan = await coordinator.handlers['turn.resume.query']({ sessionId: assignment.targetSessionId, sourceRunId: source.runId }, context);
+                    if (!plan.ok)
+                        throw new WorkHubActionEffectFailure(plan.error.code, plan.error.message);
+                    if (plan.result.disposition === 'parked') {
+                        throw new WorkHubActionEffectFailure(plan.result.reason === 'resume_feature_disabled'
+                            ? 'operation_unavailable'
+                            : 'operation_conflict', plan.result.reason === 'resume_feature_disabled'
+                            ? 'Safe-boundary resume is disabled for this Runtime Host'
+                            : 'WorkHub delegated execution is not resumable');
+                    }
+                    if (plan.result.sourceRunId !== source.runId ||
+                        plan.result.sourceTurnId !== source.turnId) {
+                        throw new WorkHubActionEffectFailure('operation_conflict', 'WorkHub resume source lineage changed during planning');
+                    }
+                    const targetTurnId = workHubResumedTurnId(actionId);
+                    const started = await coordinator.handlers['turn.resume.start']({
+                        sessionId: assignment.targetSessionId,
+                        turnId: targetTurnId,
+                        sourceRunId: plan.result.sourceRunId,
+                        sourceRuntimeEventHighWater: plan.result.sourceRuntimeEventHighWater,
+                    }, context);
+                    if (!started.ok) {
+                        throw new WorkHubActionEffectFailure(started.error.code, started.error.message);
+                    }
+                    if (started.result.kind === 'parked') {
+                        throw new WorkHubActionEffectFailure(started.result.plan.reason === 'resume_feature_disabled'
+                            ? 'operation_unavailable'
+                            : 'operation_conflict', started.result.plan.reason === 'resume_feature_disabled'
+                            ? 'Safe-boundary resume is disabled for this Runtime Host'
+                            : 'WorkHub delegated execution is not resumable');
+                    }
+                    return {
+                        outcome: 'resume_started',
+                        targetTurnId: started.result.turn.turnId,
+                    };
+                },
                 retireDelegation: async (assignment, retirement) => {
                     const disposition = await messages.cancelMessageIfPending(assignment.targetSessionId, assignment.targetMessageId, retirement.cancellationClaimId);
                     if (disposition.kind === 'recovering') {
@@ -1076,11 +1140,11 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                         return { outcome: 'not_owned', targetTurnId: disposition.turnId };
                     }
                     if (disposition.kind === 'owned_root') {
-                        const identity = {
+                        const identity = await coordinator.readLatestRootTurnLineage({
                             sessionId: assignment.targetSessionId,
                             turnId: disposition.turnId,
                             runId: disposition.runId,
-                        };
+                        });
                         return retirement.cause === 'direct_stop'
                             ? stopOwnedWorkHubRoot(coordinator, identity, retirement.cancellationClaimId)
                             : stopReplacedWorkHubRoot(coordinator, identity);
@@ -1205,7 +1269,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 },
             },
             resolveCreateTarget: async () => {
-                const { projectId: _projectId, ...target } = await sessionCatalog.resolveExternalSessionImportTarget();
+                const { projectId: _projectId, ...target } = await sessionCatalog.resolveDefaultCreateTarget();
                 return { ...target, permissionMode: 'explore' };
             },
             requestDrain: context.requestDrain,

package/node_modules/@maka/runtime-host/dist/server/external-session-coordinator.js

@@ -18,7 +18,7 @@
  */
 import { ExternalSessionImporter } from '@maka/storage/external-sessions';
 import { EXTERNAL_SESSION_CWD_MAX_BYTES, EXTERNAL_SESSION_IMPORTED_SESSION_IDS_MAX_ITEMS, EXTERNAL_SESSION_NAME_MAX_BYTES, EXTERNAL_SESSION_PAGE_MAX_ITEMS, EXTERNAL_SESSION_RESULT_MAX_BYTES, EXTERNAL_SESSION_SOURCE_MAX_ITEMS, EXTERNAL_SESSION_SOURCE_SESSION_ID_MAX_BYTES, } from '../protocol/index.js';
-import { projectSessionCatalogRecord, SessionOperationFailure, } from './session-catalog-coordinator.js';
+import { projectSessionCatalogRecord, SessionOperationFailure, NoUsableImportModelError, } from './session-catalog-coordinator.js';
 import { WorkspaceResolutionError } from './workspace-resolver.js';
 /** Source discovery/conversion stays host-side so raw transcripts never cross the wire. */
 export class HostExternalSessionCoordinator {
@@ -172,6 +172,9 @@ export class HostExternalSessionCoordinator {
             target = await this.#resolveTarget();
         }
         catch (error) {
+            if (error instanceof NoUsableImportModelError) {
+                return importFailure('model_unavailable', error.message);
+            }
             if (error instanceof SessionOperationFailure) {
                 return importFailure(error.code, error.message);
             }
@@ -194,9 +197,9 @@ export class HostExternalSessionCoordinator {
         }
         catch (error) {
             if (!commitAttempted) {
-                return importFailure(isSourceSessionNotFound(error) ? 'not_found' : 'invalid_request', isSourceSessionNotFound(error)
+                return importFailure(isSourceSessionNotFound(error) ? 'not_found' : 'source_unreadable', isSourceSessionNotFound(error)
                     ? 'External Session does not exist'
-                    : 'External Session could not be converted');
+                    : 'External Session could not be read or converted');
             }
             this.#requestDrain();
             return importFailure('commit_outcome_unknown', 'External Session import outcome is unknown; check the Session list before retrying');

package/node_modules/@maka/runtime-host/dist/server/host-kernel.js

@@ -25,7 +25,7 @@ import { removeHostRegistration, writeHostRegistration } from '../control/regist
 import { decodeClientFrame, encodeProtocolMessage, HOST_OPERATION_SPECS, negotiateProtocol, RUNTIME_HOST_COMPATIBILITY_EPOCH, RUNTIME_HOST_PROTOCOL_VERSION, RUNTIME_HOST_REGISTRATION_SCHEMA_VERSION, requireHostGeneration, } from '../protocol/index.js';
 import { RuntimeHostConnectionSession, } from './connection-session.js';
 import { composeOperationHandlers, createUnavailableDomainOperationHandlers, } from './operation-dispatcher.js';
-import { issueAccessCredential, acknowledgeCollaborationTurnRequest, createCollaborationTurnRequest, decideCollaborationTurnRequest, withdrawCollaborationTurnRequest, finalizeAccessCredential, prepareCollaborationInvitation, queryCollaborationTurnRequests, prepareAccessCredential, prepareAccessCredentialRotation, replaceAccessCredential, revokeAccessCredential, revokeAccessPrincipal, revokeAccessCredentialRotation, revokeCollaborationGrant, revokeCollaborationPrincipal, } from './access-authority.js';
+import { issueAccessCredential, acknowledgeCollaborationTurnRequest, createCollaborationTurnRequest, decideCollaborationTurnRequest, withdrawCollaborationTurnRequest, finalizeAccessCredential, prepareCollaborationInvitation, queryCollaborationTurnRequests, prepareAccessCredential, prepareAccessCredentialRotation, replaceAccessCredential, revokeAccessCredential, revokeAccessPrincipal, revokeAccessCredentialRotation, revokeCollaborationGrant, revokeCollaborationPrincipal, renameCollaborationPrincipal, } from './access-authority.js';
 import { runtimeHostLogBuffer } from '../process-diagnostics.js';
 import { startLocalRuntimeHostListenerSet, } from './listener-set.js';
 import { HostResidencyRegistry } from './host-residency-registry.js';
@@ -164,7 +164,8 @@ export class RuntimeHostKernel {
     get compositionDescriptor() {
         return this.#options.composition.descriptor;
     }
-    close() {
+    close(input) {
+        this.#shutdownReason ??= input?.reason;
         this.#requestDrain();
         return this.closed;
     }
@@ -502,6 +503,7 @@ export class RuntimeHostKernel {
                 ok: true,
                 result: {
                     ...this.#statusSnapshot(),
+                    upgradeBlockingActivity: this.#hasUpgradeBlockingActivity(0),
                     compositionModules: this.#composition?.moduleIds ?? [],
                     residencies: this.#residencies.snapshot(),
                     protocolVersion: RUNTIME_HOST_PROTOCOL_VERSION,
@@ -531,7 +533,7 @@ export class RuntimeHostKernel {
                         },
                     };
                 }
-                if (!input.allowInterruptActiveTasks && this.#hasUpgradeBlockingActivity()) {
+                if (!input.allowInterruptActiveTasks && this.#hasUpgradeBlockingActivity(1)) {
                     return { ok: true, result: { kind: 'active_tasks' } };
                 }
                 this.#shutdownReason = 'retirement';
@@ -560,6 +562,7 @@ export class RuntimeHostKernel {
                     },
                 },
             'collaboration.grant.revoke': async (input) => this.#settleAccessCredentialMutation(revokeCollaborationGrant(this.#options.accessAuthority, input)),
+            'collaboration.principal.rename': async (input) => renameCollaborationPrincipal(this.#options.accessAuthority, input),
             'collaboration.principal.revoke': async (input) => this.#settleAccessCredentialMutation(revokeCollaborationPrincipal(this.#options.accessAuthority, input.principalId)),
             'collaboration.turn-request.create': async (input, context) => this.#settleAccessCredentialMutation(createCollaborationTurnRequest(this.#options.accessAuthority, context.principal, input)),
             'collaboration.turn-request.query': async (input, context) => queryCollaborationTurnRequests(this.#options.accessAuthority, {
@@ -605,13 +608,16 @@ export class RuntimeHostKernel {
             residencies: this.#residencies.snapshot(),
         };
     }
-    #hasUpgradeBlockingActivity() {
+    #hasUpgradeBlockingActivity(selfCommands) {
         // The request's own accepted transport is expected. Any other live
         // connection arrived after discovery or remained attached and therefore
-        // requires explicit interruption authority before retirement.
+        // requires explicit interruption authority before retirement. Callers
+        // pass how many of the in-flight commands are their own: the
+        // `host.upgrade.prepare` command counts itself, while the diagnostics
+        // query path runs outside the command counter.
         if (this.#acceptedTransports.size > 1)
             return true;
-        if (this.#activeCommandOperations > 1)
+        if (this.#activeCommandOperations > selfCommands)
             return true;
         return this.#residencies.drainCount > 0;
     }

package/node_modules/@maka/runtime-host/dist/server/message-coordinator.js

@@ -112,11 +112,18 @@ export class HostMessageCoordinator {
         for (const messageId of input.messageIds) {
             const disposition = await this.#resolveMessageExecution(input.sessionId, messageId);
             if (disposition.kind === 'owned_root' || disposition.kind === 'shared_turn') {
+                // This read projects current execution, including safe-boundary
+                // continuations. The Message's durable admission ownership is unchanged.
+                const latest = await this.#root.readLatestRootTurnLineage({
+                    sessionId: input.sessionId,
+                    turnId: disposition.turnId,
+                    runId: disposition.runId,
+                });
                 resolutions.push({
                     messageId,
                     state: 'owned',
-                    turnId: disposition.turnId,
-                    runId: disposition.runId,
+                    turnId: latest.turnId,
+                    runId: latest.runId,
                 });
                 continue;
             }

package/node_modules/@maka/runtime-host/dist/server/root-admission-owner.js

@@ -62,6 +62,13 @@ export class RootAdmissionOwner {
                 previousRootTurnId: current?.turnId ?? null,
             });
             const admission = result.admission;
+            if (result.kind === 'conflict') {
+                const known = this.#admissionsBySession.get(input.sessionId)?.get(admission.turnId);
+                if (!known || !sameRootAdmission(known, admission)) {
+                    throw new Error('Durable Root Turn conflict is outside the owned chain');
+                }
+                return Object.freeze({ kind: 'conflict', admission: known });
+            }
             if (admission.sessionId !== input.sessionId ||
                 admission.turnId !== input.turnId ||
                 admission.previousRootTurnId !== (current?.turnId ?? null)) {

package/node_modules/@maka/runtime-host/dist/server/root-turn-coordinator.js

@@ -223,6 +223,21 @@ export class RootTurnCoordinator {
         }
         return this.#admissions.has(sessionId) ? { kind: 'reserved' } : { kind: 'idle' };
     }
+    /** Returns the newest Host-admitted continuation descended from one root execution. */
+    async readLatestRootTurnLineage(identity) {
+        const origin = await this.stores.agentRunStore.readRootTurnAdmission(identity.sessionId, identity.turnId);
+        if (!origin || origin.runId !== identity.runId) {
+            throw new RuntimeMessageAuthorityInvariantError(`Root execution ${identity.turnId}/${identity.runId} has no durable admission`);
+        }
+        let latest = origin;
+        while (true) {
+            const continuation = await this.stores.agentRunStore.readRootTurnContinuationAdmission(identity.sessionId, latest.turnId, latest.runId);
+            if (!continuation)
+                break;
+            latest = continuation;
+        }
+        return { sessionId: latest.sessionId, turnId: latest.turnId, runId: latest.runId };
+    }
     startHostedExternalTransition(input, context) {
         return this.startInteractiveRootMessage({
             sessionId: input.sessionId,
@@ -1291,6 +1306,12 @@ export class RootTurnCoordinator {
                     sourceMessages: [],
                     admittedAt: Date.now(),
                 });
+                if (admitted.kind === 'conflict') {
+                    return {
+                        kind: 'complete',
+                        outcome: operationConflict('This root execution already has a different continuation Turn'),
+                    };
+                }
                 if (admitted.admission.runId !== continuation.runId ||
                     !isDeepStrictEqual(admitted.admission.execution, execution)) {
                     throw new RuntimeMessageAuthorityInvariantError('Safe-boundary continuation admission changed identity');