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

package/node_modules/@maka/core/dist/provider-registry.js

@@ -116,12 +116,12 @@ if (zenmux.api !== 'https://zenmux.ai/api/v1') {
     throw new Error('models.dev ZenMux provider facts are missing the official OpenAI-compatible API');
 }
 const zenmuxModelProviderOverrides = GENERATED_MODELS_DEV_MODEL_PROVIDER_OVERRIDES.zenmux;
-if (zenmuxModelProviderOverrides['anthropic/claude-sonnet-4.6']?.npm !== '@ai-sdk/anthropic' ||
-    zenmuxModelProviderOverrides['anthropic/claude-sonnet-4.6']?.api !==
+if (zenmuxModelProviderOverrides['anthropic/claude-sonnet-4.6']?.adapter.kind !== 'anthropic' ||
+    zenmuxModelProviderOverrides['anthropic/claude-sonnet-4.6']?.baseUrl !==
         'https://zenmux.ai/api/anthropic/v1') {
     throw new Error('models.dev ZenMux snapshot is missing its Anthropic model-level protocol override');
 }
-if (zenmuxModelProviderOverrides['openai/gpt-5.4']?.npm !== '@ai-sdk/openai') {
+if (zenmuxModelProviderOverrides['openai/gpt-5.4']?.adapter.kind !== 'openai') {
     throw new Error('models.dev ZenMux snapshot is missing its native OpenAI model-level protocol override');
 }
 const zenmuxOpenAICompatibleMetadata = Object.fromEntries(Object.entries(GENERATED_MODELS_DEV_METADATA.zenmux).filter(([id]) => zenmuxModelProviderOverrides[id] === undefined));
@@ -505,6 +505,14 @@ const providerRegistry = {
         fallbackModels: [...kimiCodingPlanModelIds],
         status: 'ready',
         runtimeAdapter: { kind: 'anthropic', auth: 'api-key', normalizeBaseUrl: true },
+        protocolAdapters: {
+            'openai-chat': {
+                kind: 'openai-compatible',
+                name: 'provider',
+                normalizeUsage: true,
+                normalizeBaseUrl: true,
+            },
+        },
         modelDiscovery: { kind: 'protocol' },
         category: 'domestic',
         catalogGroup: 'plans',
@@ -891,6 +899,10 @@ const providerRegistry = {
         fallbackModels: opencodeModelIds,
         status: 'ready',
         runtimeAdapter: { kind: 'openai-compatible', name: 'provider' },
+        protocolAdapters: {
+            'anthropic-messages': { kind: 'anthropic', auth: 'api-key', normalizeBaseUrl: true },
+            'openai-responses': { kind: 'openai', apiProtocol: 'openai-responses' },
+        },
         modelDiscovery: { kind: 'protocol' },
         category: 'overseas',
         catalogGroup: 'plans',
@@ -904,6 +916,10 @@ const providerRegistry = {
         fallbackModels: opencodeGoModelIds,
         status: 'ready',
         runtimeAdapter: { kind: 'openai-compatible', name: 'provider' },
+        protocolAdapters: {
+            'anthropic-messages': { kind: 'anthropic', auth: 'api-key', normalizeBaseUrl: true },
+            'openai-responses': { kind: 'openai', apiProtocol: 'openai-responses' },
+        },
         modelDiscovery: { kind: 'protocol' },
         category: 'overseas',
         catalogGroup: 'plans',
@@ -1182,6 +1198,22 @@ const providerRegistry = {
         signupUrl: 'https://modelstudio.console.alibabacloud.com/',
         catalogOrder: 41.4,
     },
+    commandcode: {
+        label: 'Command Code',
+        baseUrl: 'https://api.commandcode.ai/provider/v1',
+        authKind: 'api_key',
+        fallbackModels: [],
+        status: 'ready',
+        runtimeAdapter: { kind: 'openai-compatible', name: 'provider' },
+        protocolAdapters: {
+            'anthropic-messages': { kind: 'anthropic', auth: 'bearer', normalizeBaseUrl: true },
+        },
+        modelDiscovery: { kind: 'protocol', modelProtocols: 'commandcode' },
+        category: 'overseas',
+        catalogGroup: 'plans',
+        signupUrl: 'https://commandcode.ai/docs/plans/goat',
+        catalogOrder: 41.5,
+    },
     'cloudflare-workers-ai': {
         label: cloudflareWorkersAi.name,
         baseUrl: '',
@@ -1299,7 +1331,16 @@ const providerRegistry = {
         authKind: 'oauth_token',
         fallbackModels: githubCopilotModelIds,
         status: 'ready',
-        runtimeAdapter: { kind: 'github-copilot' },
+        runtimeAdapter: { kind: 'openai-compatible', name: 'provider', includeUsage: false },
+        protocolAdapters: {
+            'anthropic-messages': {
+                kind: 'anthropic',
+                auth: 'bearer',
+                normalizeBaseUrl: true,
+                includeBetaHeaders: false,
+            },
+            'openai-responses': { kind: 'openai', apiProtocol: 'openai-responses' },
+        },
         modelDiscovery: { kind: 'protocol', auth: 'github-copilot' },
         category: 'oauth',
         signupUrl: 'https://github.com/features/copilot/plans',

package/node_modules/@maka/core/dist/record-schema.js

@@ -19,11 +19,18 @@
 /**
  * Defines a JSON object shape while making schema additions a type error until
  * both the required and optional key lists are updated.
+ *
+ * `retired` names keys older writers persisted that this type no longer has.
+ * They are accepted on read and dropped by {@link pickShape}, so what the shape
+ * emits may shrink freely while what it accepts only grows. Removing a key from
+ * `optional` without listing it here makes every stored record carrying it fail
+ * validation outright.
  */
 export function defineObjectShape() {
-    return (required, optional) => ({
+    return (required, optional, retired = []) => ({
         required,
         allowed: new Set([...required, ...optional]),
+        retired: new Set(retired),
     });
 }
 export function isRecord(value) {
@@ -31,7 +38,7 @@ export function isRecord(value) {
 }
 export function hasExactShape(value, shape) {
     return (shape.required.every((key) => Object.hasOwn(value, key)) &&
-        Object.keys(value).every((key) => shape.allowed.has(key)));
+        Object.keys(value).every((key) => shape.allowed.has(key) || shape.retired?.has(key) === true));
 }
 /**
  * Narrows a record to the keys a shape allows. `undefined` entries are dropped

package/node_modules/@maka/core/dist/runtime-boundary.js

@@ -65,6 +65,8 @@ export function createRuntimeBoundaryCursor(segments) {
     const invocationIds = new Set();
     const runIds = new Set();
     const turnIds = new Set();
+    let previousTurnId;
+    let protocol = 'runtime_boundary_cursor_v1';
     for (const segment of canonicalSegments) {
         if (segment.identity.sessionId !== sessionId) {
             throw new Error('Runtime boundary segments must belong to the same session');
@@ -78,24 +80,30 @@ export function createRuntimeBoundaryCursor(segments) {
         }
         invocationIds.add(segment.identity.invocationId);
         if (turnIds.has(segment.identity.turnId)) {
-            throw new Error('Runtime boundary lineage contains a duplicate turnId');
+            if (previousTurnId !== segment.identity.turnId) {
+                throw new Error('Runtime boundary lineage returns to a previous turnId');
+            }
+            protocol = 'runtime_boundary_cursor_v2';
         }
         turnIds.add(segment.identity.turnId);
+        previousTurnId = segment.identity.turnId;
     }
     return {
-        protocol: 'runtime_boundary_cursor_v1',
+        protocol,
         segments: canonicalSegments,
-        manifestDigest: digestRuntimeBoundaryManifest(canonicalSegments),
+        manifestDigest: digestRuntimeBoundaryManifest(canonicalSegments, protocol),
     };
 }
-export function digestRuntimeBoundaryManifest(segments) {
+export function digestRuntimeBoundaryManifest(segments, protocol = 'runtime_boundary_cursor_v1') {
     const canonicalSegments = segments.map(decodeRuntimePrefixSegment);
     const json = stableJsonStringify({
-        protocol: 'runtime_boundary_cursor_v1',
+        protocol,
         segments: canonicalSegments,
     });
     const hash = nodeCrypto.createHash('sha256');
-    updateLengthPrefixed(hash, Buffer.from('maka.runtime-boundary-manifest.v1', 'utf8'));
+    updateLengthPrefixed(hash, Buffer.from(protocol === 'runtime_boundary_cursor_v1'
+        ? 'maka.runtime-boundary-manifest.v1'
+        : 'maka.runtime-boundary-manifest.v2', 'utf8'));
     updateLengthPrefixed(hash, Buffer.from(json, 'utf8'));
     return `sha256:${hash.digest('hex')}`;
 }
@@ -115,13 +123,16 @@ export function decodeRuntimePrefixSegment(value) {
 export function decodeRuntimeBoundaryCursor(value) {
     if (!isRecord(value) ||
         !hasExactKeys(value, ['protocol', 'segments', 'manifestDigest']) ||
-        value.protocol !== 'runtime_boundary_cursor_v1' ||
+        (value.protocol !== 'runtime_boundary_cursor_v1' &&
+            value.protocol !== 'runtime_boundary_cursor_v2') ||
         !Array.isArray(value.segments) ||
         value.segments.length === 0) {
         throw new Error('Invalid RuntimeEvent boundary cursor');
     }
     const segments = value.segments.map(decodeRuntimePrefixSegment);
     const cursor = createRuntimeBoundaryCursor(segments);
+    if (cursor.protocol !== value.protocol)
+        throw new Error('RuntimeEvent boundary cursor version mismatch');
     const manifestDigest = decodeBoundaryDigest(value.manifestDigest);
     if (cursor.manifestDigest !== manifestDigest) {
         throw new Error('RuntimeEvent boundary manifest digest mismatch');
@@ -173,12 +184,21 @@ export function decodeContinuationClaim(value) {
         throw new Error('Continuation claim target invocationId reuses source identity');
     }
     const targetTurnId = value.target.turnId;
-    if (boundary.segments.some((segment) => segment.identity.turnId === targetTurnId)) {
-        throw new Error('Continuation claim target turnId reuses source identity');
-    }
     const targetOpening = decodeRuntimeInvocationOpened(value.targetOpening);
     const openSource = targetOpening.source;
-    if (openSource.kind !== 'continuation' ||
+    if (openSource.kind === 'handoff') {
+        if (targetTurnId !== source.identity.turnId) {
+            throw new Error('Handoff claim must preserve the logical turnId');
+        }
+        const root = boundary.segments.find((segment) => segment.identity.turnId === targetTurnId);
+        if (root?.identity.runId !== openSource.rootRunId) {
+            throw new Error('Handoff claim logical root mismatch');
+        }
+    }
+    else if (boundary.segments.some((segment) => segment.identity.turnId === targetTurnId)) {
+        throw new Error('Continuation claim target turnId reuses source identity');
+    }
+    if ((openSource.kind !== 'continuation' && openSource.kind !== 'handoff') ||
         openSource.claimId !== value.claimId ||
         openSource.boundaryDigest !== boundaryDigest ||
         openSource.sourceInvocationId !== source.identity.invocationId ||

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

@@ -31,12 +31,15 @@
  * Phase 1 scope: types + small pure helpers only. No storage, runner,
  * projection, or ledger logic lives here. Those arrive in later nodes.
  */
+import { isModelRetryDecision } from './model-failure.js';
+import { isRuntimeHandoffPause, runtimeHandoffPause, } from './runtime-handoff.js';
 import { isMessageContent, normalizeMessageContent, } from './events.js';
 import { INTERACTION_ID_MAX_BYTES, INTERACTION_TOOL_NAME_MAX_BYTES, decodeInteractionRequest, } from './interaction.js';
 import { isPermissionMode, } from './permission.js';
 import { isCollaborationMode } from './collaboration.js';
 import { isAgentSwarmAuthorizationSource, isEffectiveOrchestrationSource, isOrchestrationMode, } from './orchestration.js';
 import { isToolMode } from './tool-mode.js';
+import { isRuntimeSystemNoteKind, } from './session.js';
 import { decodeTurnOrigin } from './turn-origin.js';
 import { defineObjectShape, hasExactShape, isFiniteNumber, isOptionalMember, isOptionalString, isRecord, isStringArray, } from './record-schema.js';
 import { isPermissionDecisionFields, isPermissionRequestPayload, isUserQuestionRequest, } from './interaction-record-schema.js';
@@ -106,6 +109,7 @@ export const RUNTIME_EVENT_CONTENT_KINDS = [
     'function_call',
     'function_response',
     'error',
+    'system_note',
     'invocation_opened',
 ];
 export const TOOL_BOUNDARY_PROTOCOL_V1 = 't1_after_preflight_v1';
@@ -178,7 +182,8 @@ const TEXT_CONTENT_SHAPE = defineObjectShape()(['kind', 'text'], [
 const THINKING_CONTENT_SHAPE = defineObjectShape()(['kind', 'text'], ['signature', 'providerOptions']);
 const FUNCTION_CALL_CONTENT_SHAPE = defineObjectShape()(['kind', 'id', 'name', 'args'], ['providerOptions', 'providerExecuted']);
 const FUNCTION_RESPONSE_CONTENT_SHAPE = defineObjectShape()(['kind', 'id', 'name', 'result'], ['isError', 'providerExecuted', 'providerOutput', 'modelProjection']);
-const ERROR_CONTENT_SHAPE = defineObjectShape()(['kind', 'message'], ['code', 'reason', 'details']);
+const ERROR_CONTENT_SHAPE = defineObjectShape()(['kind', 'message'], ['code', 'reason', 'details', 'retry']);
+const SYSTEM_NOTE_CONTENT_SHAPE = defineObjectShape()(['kind', 'note'], ['data']);
 const INVOCATION_OPENED_CONTENT_SHAPE = defineObjectShape()(['kind', 'protocol', 'route', 'configuration', 'root', 'source'], ['lineage']);
 const INVOCATION_ROUTE_RUNTIME_SHAPE = defineObjectShape()(['provenance', 'backendKind', 'llmConnectionId', 'llmConnectionSlug', 'modelId'], ['providerStateIdentity']);
 const INVOCATION_ROUTE_UNKNOWN_SHAPE = defineObjectShape()(['provenance', 'backendKind', 'llmConnectionSlug', 'modelId'], []);
@@ -204,6 +209,16 @@ const INVOCATION_LINEAGE_SHAPE = defineObjectShape()([], [
 ]);
 const INVOCATION_CONTINUATION_SOURCE_SHAPE = defineObjectShape()(['kind', 'sourceInvocationId', 'sourceRunId', 'sourceTurnId', 'sourceRuntimeEventHighWater'], ['claimId', 'boundaryDigest']);
 const INVOCATION_FRESH_SOURCE_SHAPE = defineObjectShape()(['kind'], []);
+const INVOCATION_HANDOFF_SOURCE_SHAPE = defineObjectShape()([
+    'kind',
+    'rootRunId',
+    'sourceInvocationId',
+    'sourceRunId',
+    'sourceTurnId',
+    'sourceRuntimeEventHighWater',
+    'claimId',
+    'boundaryDigest',
+], []);
 const INVOCATION_ROOT_SHAPES = {
     user: defineObjectShape()(['kind'], []),
     context_compact: defineObjectShape()(['kind'], []),
@@ -213,6 +228,7 @@ const INVOCATION_ROOT_SHAPES = {
     legacy_automation: defineObjectShape()(['kind', 'legacyAutomationId'], []),
 };
 const RUNTIME_ACTIONS_SHAPE = defineObjectShape()([], [
+    'handoffPause',
     'stateDelta',
     'artifactDelta',
     'permissionRequest',
@@ -236,7 +252,7 @@ const RUNTIME_ACTIONS_SHAPE = defineObjectShape()([], [
 const RUNTIME_MANAGED_MUTATION_TERMINAL_SHAPE = defineObjectShape()(['protocol', 'operationId', 'dispatchEventId', 'workspaceInstanceId', 'terminalKind'], []);
 const ANSWER_ACCEPTED_IDENTITY_SHAPE = defineObjectShape()(['requestId'], []);
 const PERMISSION_CLOSURE_ACCEPTED_SHAPE = defineObjectShape()(['requestId', 'reason'], []);
-const RUNTIME_PERMISSION_DECISION_SHAPE = defineObjectShape()(['requestId', 'decision'], ['rememberForTurn', 'reviewer', 'rationale', 'riskLevel', 'toolName']);
+const RUNTIME_PERMISSION_DECISION_SHAPE = defineObjectShape()(['requestId', 'decision'], ['rememberForTurn', 'reviewer', 'rationale', 'riskLevel', 'toolName', 'hint']);
 const UTF8 = new TextEncoder();
 const RUNTIME_TOOL_DISPATCH_SHAPE = defineObjectShape()([
     'protocol',
@@ -341,6 +357,7 @@ export function decodeRuntimeEvent(value) {
         (value.refs !== undefined && !isRuntimeEventRefs(value.refs))) {
         throw new Error('Invalid RuntimeEvent schema');
     }
+    runtimeHandoffPause(value);
     if (isRecord(value.content) && value.content.kind === 'text') {
         return {
             ...value,
@@ -415,8 +432,13 @@ function isRuntimeEventContent(value) {
             return (hasExactShape(value, ERROR_CONTENT_SHAPE) &&
                 isOptionalString(value.code) &&
                 isOptionalString(value.reason) &&
+                (value.retry === undefined || isModelRetryDecision(value.retry)) &&
                 typeof value.message === 'string' &&
                 (value.details === undefined || isStringArray(value.details) || isRecord(value.details)));
+        case 'system_note':
+            return (hasExactShape(value, SYSTEM_NOTE_CONTENT_SHAPE) &&
+                typeof value.note === 'string' &&
+                isRuntimeSystemNoteKind(value.note));
         case 'invocation_opened':
             return isRuntimeInvocationOpened(value);
         default:
@@ -508,8 +530,14 @@ function isRuntimeInvocationOpenSource(value) {
         return false;
     if (value.kind === 'fresh')
         return hasExactShape(value, INVOCATION_FRESH_SOURCE_SHAPE);
-    return (value.kind === 'continuation' &&
-        hasExactShape(value, INVOCATION_CONTINUATION_SOURCE_SHAPE) &&
+    return (((value.kind === 'continuation' &&
+        hasExactShape(value, INVOCATION_CONTINUATION_SOURCE_SHAPE)) ||
+        (value.kind === 'handoff' &&
+            hasExactShape(value, INVOCATION_HANDOFF_SOURCE_SHAPE) &&
+            isNonEmptyString(value.rootRunId) &&
+            isNonEmptyString(value.claimId) &&
+            isSha256Digest(value.boundaryDigest) &&
+            value.sourceRuntimeEventHighWater > 0)) &&
         isNonEmptyString(value.sourceInvocationId) &&
         isNonEmptyString(value.sourceRunId) &&
         isNonEmptyString(value.sourceTurnId) &&
@@ -554,7 +582,8 @@ function isRuntimeEventActions(value) {
         Object.keys(value).some((key) => key !== 'permissionClosureAccepted')) {
         return false;
     }
-    return ((value.stateDelta === undefined || isRecord(value.stateDelta)) &&
+    return ((value.handoffPause === undefined || isRuntimeHandoffPause(value.handoffPause)) &&
+        (value.stateDelta === undefined || isRecord(value.stateDelta)) &&
         (value.artifactDelta === undefined ||
             (isRecord(value.artifactDelta) &&
                 Object.values(value.artifactDelta).every((item) => typeof item === 'string' || typeof item === 'boolean' || isFiniteNumber(item)))) &&
@@ -621,7 +650,8 @@ function isRuntimeEventPermissionDecision(value) {
         (value.toolName === undefined ||
             (typeof value.toolName === 'string' &&
                 value.toolName.length > 0 &&
-                UTF8.encode(value.toolName).byteLength <= INTERACTION_TOOL_NAME_MAX_BYTES)));
+                UTF8.encode(value.toolName).byteLength <= INTERACTION_TOOL_NAME_MAX_BYTES)) &&
+        isOptionalString(value.hint));
 }
 function isRuntimeEventAnswerAcceptedIdentity(value) {
     return (isRecord(value) &&
@@ -804,6 +834,7 @@ export function runtimeEventHasModelVisibleContent(event) {
         case 'function_response':
             return true;
         case 'error':
+        case 'system_note':
         case 'invocation_opened':
             return false;
     }

package/node_modules/@maka/core/dist/runtime-handoff.js

@@ -0,0 +1,98 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { defineObjectShape, hasExactShape, isRecord } from './record-schema.js';
+import { stableJsonStringify } from './tool-args-identity.js';
+const PAUSE_SHAPE = defineObjectShape()([
+    'protocol',
+    'handoffId',
+    'hostEpoch',
+    'rootRunId',
+    'successorRunId',
+    'successorInvocationId',
+    'claimId',
+    'remainingSteps',
+], []);
+export function isRuntimeHandoffPause(value) {
+    return (isRecord(value) &&
+        hasExactShape(value, PAUSE_SHAPE) &&
+        value.protocol === 'runtime_handoff_pause_v1' &&
+        (value.remainingSteps === null ||
+            (Number.isSafeInteger(value.remainingSteps) && value.remainingSteps > 0)) &&
+        [
+            value.handoffId,
+            value.hostEpoch,
+            value.rootRunId,
+            value.successorRunId,
+            value.successorInvocationId,
+            value.claimId,
+        ].every((id) => typeof id === 'string' &&
+            id.length > 0 &&
+            id.length <= 256 &&
+            !/[\u0000-\u001f\u007f]/u.test(id)));
+}
+/** The seal cannot simultaneously publish content or claim a logical outcome. */
+export function runtimeHandoffPause(event) {
+    const pause = event.actions?.handoffPause;
+    if (pause === undefined)
+        return undefined;
+    if (!isRuntimeHandoffPause(pause) ||
+        event.partial !== false ||
+        event.role !== 'system' ||
+        (event.author !== 'host' && event.author !== 'system') ||
+        event.status !== undefined ||
+        event.content !== undefined ||
+        event.actions?.endInvocation !== true ||
+        Object.keys(event.actions).some((key) => key !== 'endInvocation' && key !== 'handoffPause') ||
+        pause.successorRunId === event.runId ||
+        pause.successorRunId === event.invocationId ||
+        pause.successorInvocationId === event.invocationId ||
+        pause.successorRunId === pause.rootRunId) {
+        throw new Error('Invalid Runtime handoff pause seal');
+    }
+    return pause;
+}
+/** Verify against source facts, not the proposed claim's description of them. */
+export function assertHandoffClaimSource(claim, prefix) {
+    const last = prefix.events.at(-1);
+    const pause = last && runtimeHandoffPause(last);
+    const source = claim.targetOpening.source;
+    if (source.kind !== 'handoff') {
+        if (pause)
+            throw new Error('A handoff pause is reserved for its authorized successor');
+        return;
+    }
+    const opening = prefix.events[0]?.content;
+    if (!pause ||
+        opening?.kind !== 'invocation_opened' ||
+        prefix.identity.sessionId !== claim.target.sessionId ||
+        prefix.identity.turnId !== claim.target.turnId ||
+        pause.claimId !== claim.claimId ||
+        pause.successorRunId !== claim.target.runId ||
+        pause.successorInvocationId !== claim.target.invocationId ||
+        pause.rootRunId !== source.rootRunId ||
+        pause.rootRunId !==
+            (opening.source.kind === 'handoff' ? opening.source.rootRunId : prefix.identity.runId) ||
+        stableJsonStringify(opening.root) !== stableJsonStringify(claim.targetOpening.root) ||
+        stableJsonStringify(opening.configuration) !==
+            stableJsonStringify(claim.targetOpening.configuration) ||
+        stableJsonStringify(opening.lineage ?? null) !==
+            stableJsonStringify(claim.targetOpening.lineage ?? null)) {
+        throw new Error('Handoff claim does not preserve the sealed source authority');
+    }
+}

package/node_modules/@maka/core/dist/runtime-invocation.js

@@ -149,7 +149,7 @@ export function runtimeInvocationOutcome(record) {
 export function isSessionInlineInvocation(opening) {
     const lineage = opening.lineage;
     return (lineage?.parentRunId === undefined ||
-        (opening.source.kind === 'continuation' && lineage.agentId === undefined));
+        (opening.source.kind !== 'fresh' && lineage.agentId === undefined));
 }
 /**
  * Is this invocation the one the Host admitted for that root execution?

package/node_modules/@maka/core/dist/runtime-logical-execution.js

@@ -0,0 +1,112 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { continuationStartEventMatchesClaim, createRuntimeBoundaryCursor, invocationMatchesClaimTarget, runtimePrefixSegment, } from './runtime-boundary.js';
+import { readRunInvocation, } from './runtime-event-store.js';
+import { assertHandoffClaimSource, runtimeHandoffPause, } from './runtime-handoff.js';
+/** All logical snapshot and command routing paths share these edge checks. */
+export async function readLogicalRuntimeExecution(store, identity, knownRoot) {
+    const root = knownRoot ?? (await readRunInvocation(store, identity.sessionId, identity.runId));
+    if (!root)
+        return undefined;
+    if (root.sessionId !== identity.sessionId ||
+        root.runId !== identity.runId ||
+        root.turnId !== identity.turnId ||
+        root.opening.source.kind === 'handoff') {
+        throw new Error('Logical execution reference does not name its original admission');
+    }
+    let tip = root;
+    let segments;
+    const seen = new Set();
+    for (;;) {
+        if (seen.has(tip.runId) || seen.size >= 64)
+            throw new Error('Invalid logical execution handoff lineage');
+        seen.add(tip.runId);
+        const events = await store.readImmutableRuntimeEvents(identity.sessionId, tip.runId);
+        const last = events.at(-1);
+        const pause = last && runtimeHandoffPause(last);
+        if (!pause)
+            return { root, tip, events, runIds: [...seen] };
+        if (pause.rootRunId !== root.runId)
+            throw new Error('Handoff seal changes the logical root');
+        const prefix = await store.readImmutableRuntimePrefix({
+            sessionId: identity.sessionId,
+            runId: tip.runId,
+        });
+        if (prefix.position.lastEventId !== last.id)
+            throw new Error('Handoff source changed after its seal');
+        if (!segments) {
+            // A manual continuation may itself become a handoff root. Preserve its
+            // earlier replay boundary without treating those earlier Turns as this Turn.
+            const source = root.opening.source;
+            if (source.kind === 'continuation') {
+                if (!source.boundaryDigest)
+                    throw new Error('Handoff requires authenticated source lineage');
+                const initial = await store.readContinuationClaimStateByBoundary(source.boundaryDigest);
+                if (!initial ||
+                    initial.startEventId !== prefix.events[0]?.id ||
+                    !invocationMatchesClaimTarget(root, initial.claim) ||
+                    !continuationStartEventMatchesClaim(prefix.events[0], initial.claim, initial.startKind)) {
+                    throw new Error('Handoff root continuation is not authenticated');
+                }
+                segments = [...initial.claim.boundary.segments];
+            }
+            else
+                segments = [];
+        }
+        segments.push(runtimePrefixSegment(prefix));
+        const boundary = createRuntimeBoundaryCursor(segments);
+        let state = await store.readContinuationClaimStateByBoundary(boundary.manifestDigest);
+        const next = await readRunInvocation(store, identity.sessionId, pause.successorRunId);
+        // A start can commit between the two reads. Authority is monotonic; refresh
+        // it once when the later opening read proves the earlier snapshot was old.
+        if (next && !state?.startEventId) {
+            state = await store.readContinuationClaimStateByBoundary(boundary.manifestDigest);
+        }
+        if (!state) {
+            if (next)
+                throw new Error('Handoff successor opened without its continuation claim');
+            return { root, tip, events, runIds: [...seen], pendingHandoff: pause };
+        }
+        assertHandoffClaimSource(state.claim, prefix);
+        if (!next) {
+            if (state.startEventId)
+                throw new Error('Handoff successor opening is missing');
+            return { root, tip, events, runIds: [...seen], pendingHandoff: pause };
+        }
+        const first = (await store.readImmutableRuntimeEvents(identity.sessionId, next.runId))[0];
+        if (state.startEventId !== first?.id ||
+            !invocationMatchesClaimTarget(next, state.claim) ||
+            !continuationStartEventMatchesClaim(first, state.claim, state.startKind)) {
+            throw new Error('Handoff successor does not match its authenticated start');
+        }
+        tip = next;
+    }
+}
+/** Resolve a durable physical proof back to its root, then authenticate membership. */
+export async function readLogicalRuntimeExecutionForRun(store, identity) {
+    const run = await readRunInvocation(store, identity.sessionId, identity.runId);
+    if (!run)
+        return undefined;
+    const rootRunId = run.opening.source.kind === 'handoff' ? run.opening.source.rootRunId : run.runId;
+    const logical = await readLogicalRuntimeExecution(store, { ...identity, runId: rootRunId });
+    if (!logical?.runIds.includes(identity.runId)) {
+        throw new Error('Physical proof is not an authenticated member of its logical execution');
+    }
+    return logical;
+}