maka-agent 0.2.0-dev.26.20260909 → 0.2.0-dev.27.20260910

package/node_modules/@maka/runtime/dist/session-export.js

@@ -0,0 +1,177 @@
+/*
+ * 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.
+ */
+/**
+ * Export one Session, and the subagent subtree under it, as a portable bundle.
+ *
+ * The preparation is `exportSessionBundleState()` in `@maka/storage`, which
+ * already takes a consistent database snapshot, keeps writers out, filters the
+ * copy down to the exported Sessions, carries the context-offload closure, and
+ * proves the result with `PRAGMA foreign_key_check`. This module is the thin
+ * part: point it at a workspace, ask for a quiescent Session, and seal what
+ * comes back with the bundle codec.
+ *
+ * What it adds on top is the manifest — the Sessions carried, the schema
+ * versions the SOURCE database registers, and the connection by slug and model
+ * so an importer can resolve it locally. No credential is carried: the state
+ * allow-list in the export policy decides what is copied, and configuration is
+ * not on it.
+ */
+import { mkdir, mkdtemp, rm, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { SessionBundleFileError, } from '@maka/storage/session-bundle-contract';
+import { createSessionBundleFileService } from '@maka/storage/session-bundle-file-service';
+import { exportSessionBundleState, SessionBundleExportError, SESSION_BUNDLE_OMITTED_EVENT_TYPES, } from '@maka/storage/session-bundle-policy';
+export const SESSION_EXPORT_MEDIA_TYPE = 'application/vnd.maka.session-export+json;version=1';
+/** Generous by design; the codec is what enforces them. */
+export const SESSION_EXPORT_BUNDLE_LIMITS = {
+    maxCompressedBytes: 2 * 1024 ** 3,
+    maxDecompressedTarBytes: 8 * 1024 ** 3,
+    maxPayloadBytes: 8 * 1024 ** 3,
+    maxFileBytes: 2 * 1024 ** 3,
+    maxEntryCount: 1_000_000,
+    maxManifestBytes: 4 * 1024 ** 2,
+    maxStateIdentityBytes: 4 * 1024 ** 2,
+    maxPathBytes: 4096,
+    maxPathDepth: 32,
+};
+export async function exportSessionBundle(input) {
+    if (!(await isDirectory(input.workspaceRoot))) {
+        return {
+            ok: false,
+            reason: { kind: 'workspace_not_found', workspaceRoot: input.workspaceRoot },
+        };
+    }
+    if (await exists(input.destination)) {
+        return { ok: false, reason: { kind: 'destination_exists' } };
+    }
+    const staging = await mkdtemp(join(tmpdir(), 'maka-session-export-'));
+    try {
+        const stateRoot = join(staging, 'state');
+        const workspaceRoot = join(staging, 'workspace');
+        // The codec seals a state tree beside a workspace tree. A Session's own
+        // files are the state; the user's project directory is not part of the
+        // conversation and is deliberately absent.
+        await mkdir(workspaceRoot, { recursive: true });
+        let plan;
+        try {
+            plan = await exportSessionBundleState({
+                stateRoot: input.workspaceRoot,
+                // Maka's desktop layout keeps state and configuration in one directory,
+                // so these are shared on purpose. Configuration stays out of the bundle
+                // because the policy copies an allow-list of state entries, not because
+                // the roots are apart.
+                configRoot: input.workspaceRoot,
+                allowShared: true,
+                destinationRoot: stateRoot,
+                sessionId: input.sessionId,
+                requireQuiescent: true,
+                includeSubtree: true,
+                omitDiagnostics: true,
+            });
+        }
+        catch (error) {
+            const failure = asExportFailure(error, input.workspaceRoot);
+            if (failure)
+                return { ok: false, reason: failure };
+            throw error;
+        }
+        const manifest = {
+            format: 'maka.session-export',
+            formatVersion: 1,
+            exportedAt: (input.now ?? Date.now)(),
+            rootSessionId: plan.sessionId,
+            sessionIds: plan.sessionIds,
+            schema: plan.sourceSchema,
+            connection: plan.connection,
+            includedEntries: plan.includedEntries,
+            excludedEntries: plan.excludedEntries,
+            diagnosticsOmitted: true,
+            omittedEventTypes: SESSION_BUNDLE_OMITTED_EVENT_TYPES,
+        };
+        const stateIdentity = {
+            mediaType: SESSION_EXPORT_MEDIA_TYPE,
+            bytes: Buffer.from(`${JSON.stringify(manifest)}\n`, 'utf8'),
+        };
+        const artifact = await createSessionBundleFileService().pack({
+            snapshot: { stateRoot, workspaceRoot, stateIdentity },
+            envelope: { sessionId: plan.sessionId },
+            destination: input.destination,
+            limits: input.limits ?? SESSION_EXPORT_BUNDLE_LIMITS,
+        });
+        return { ok: true, artifact, export: manifest };
+    }
+    catch (error) {
+        if (error instanceof SessionBundleFileError) {
+            if (error.details?.quota !== undefined) {
+                return { ok: false, reason: { kind: 'bundle_limit', details: error.details } };
+            }
+            // The precheck fails fast, but the packer publishes atomically and can
+            // still lose the race. Reporting that as a generic IO failure would give
+            // a caller a different exit code for the same outcome.
+            if (error.code === 'destination_exists') {
+                return { ok: false, reason: { kind: 'destination_exists' } };
+            }
+            return { ok: false, reason: { kind: 'io_failed', message: error.message } };
+        }
+        const failure = asExportFailure(error, input.workspaceRoot);
+        if (failure)
+            return { ok: false, reason: failure };
+        return { ok: false, reason: { kind: 'io_failed', message: String(error) } };
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true }).catch(() => { });
+    }
+}
+function asExportFailure(error, workspaceRoot) {
+    if (!(error instanceof SessionBundleExportError))
+        return undefined;
+    switch (error.code) {
+        case 'session_active':
+            return { kind: 'session_active', message: error.message };
+        case 'schema_unsupported':
+            return { kind: 'schema_unsupported', message: error.message };
+        case 'symlink':
+        case 'path_escape':
+        case 'unsupported_entry':
+            return { kind: 'artifact_unsafe', message: error.message };
+        case 'missing_entry':
+            return { kind: 'artifact_missing', message: error.message };
+        case 'invalid_root':
+            // The policy reports a missing Session through this code too, and only
+            // the message separates it from a directory that is not a workspace.
+            return /session does not exist/i.test(error.message)
+                ? { kind: 'session_not_found' }
+                : { kind: 'workspace_not_found', workspaceRoot };
+        case 'destination_not_empty':
+            return { kind: 'destination_exists' };
+        default:
+            return { kind: 'io_failed', message: error.message };
+    }
+}
+async function isDirectory(path) {
+    return stat(path)
+        .then((metadata) => metadata.isDirectory())
+        .catch(() => false);
+}
+async function exists(path) {
+    return stat(path)
+        .then(() => true)
+        .catch(() => false);
+}

package/node_modules/@maka/runtime/package.json

@@ -76,8 +76,25 @@
     "./plan-mode": "./dist/plan-mode.js",
     "./plan-tools": "./dist/plan-tools.js",
     "./plugin-composition-loader": "./dist/plugin-composition-loader.js",
+    "./plugin-command-service": "./dist/plugin-command-service.js",
+    "./plugin-data-services": "./dist/plugin-data-services.js",
+    "./plugin-goal-service": "./dist/plugin-goal-service.js",
+    "./plugin-lsp-service": "./dist/plugin-lsp-service.js",
+    "./plugin-session-query-service": "./dist/plugin-session-query-service.js",
+    "./plugin-shell-env-service": "./dist/plugin-shell-env-service.js",
+    "./plugin-skill-service": "./dist/plugin-skill-service.js",
+    "./plugin-agent-service": "./dist/plugin-agent-service.js",
+    "./plugin-attachment-service": "./dist/plugin-attachment-service.js",
+    "./plugin-approval-service": "./dist/plugin-approval-service.js",
+    "./plugin-fs-service": "./dist/plugin-fs-service.js",
     "./plugin-kernel": "./dist/plugin-kernel.js",
+    "./plugin-llm-service": "./dist/plugin-llm-service.js",
     "./plugin-runtime": "./dist/plugin-runtime.js",
+    "./plugin-scope-registry": "./dist/plugin-scope-registry.js",
+    "./plugin-system-prompt-service": "./dist/plugin-system-prompt-service.js",
+    "./plugin-shell-service": "./dist/plugin-shell-service.js",
+    "./plugin-user-question-service": "./dist/plugin-user-question-service.js",
+    "./plugin-web-service": "./dist/plugin-web-service.js",
     "./plugin-tool-service": "./dist/plugin-tool-service.js",
     "./process-tree-terminator": "./dist/process-tree-terminator.js",
     "./provider-request-telemetry": "./dist/provider-request-telemetry.js",
@@ -88,6 +105,7 @@
     "./sandbox-boundary-tool": "./dist/sandbox-boundary-tool.js",
     "./scheduled-task-tools": "./dist/scheduled-task-tools.js",
     "./session-recap": "./dist/session-recap.js",
+    "./session-export": "./dist/session-export.js",
     "./session-trace-projection": "./dist/session-trace-projection.js",
     "./shell-detect": "./dist/shell-detect.js",
     "./shell-run-contract": "./dist/shell-run-contract.js",

package/node_modules/@maka/runtime-host/dist/client/host-handoff-copy.js

@@ -22,6 +22,7 @@ export function formatHostHandoff(view, locale) {
     const tw = locale === 'zh-TW';
     const titles = tw
         ? {
+            replacement_required: '需要切換 WSL 背景服務',
             busy: '背景服務仍在使用中',
             activity_unknown: '需要確認是否停止背景服務',
             operator_required: '背景服務需要手動更新',
@@ -30,6 +31,7 @@ export function formatHostHandoff(view, locale) {
         }
         : zh
             ? {
+                replacement_required: '需要切换 WSL 后台服务',
                 busy: '后台服务仍在使用中',
                 activity_unknown: '需要确认是否停止后台服务',
                 operator_required: '后台服务需要手动更新',
@@ -37,6 +39,7 @@ export function formatHostHandoff(view, locale) {
                 retry_required: '暂时无法完成交接',
             }
             : {
+                replacement_required: 'Switch the WSL background service',
                 busy: 'Your background service is still in use',
                 activity_unknown: 'Confirm before stopping the service',
                 operator_required: 'The background service needs a manual update',
@@ -45,6 +48,7 @@ export function formatHostHandoff(view, locale) {
             };
     const descriptions = tw
         ? {
+            replacement_required: '目前尚未更新。選擇繼續後，將透過已安裝的管理程式安全停止舊服務並啟動選定版本；有進行中的工作時會另行確認。',
             busy: '其他連線或正在執行的工作阻止了自動交接。停止並繼續可能中斷這些工作。',
             activity_unknown: '背景服務與目前用戶端不相容，且無法確認有哪些工作仍在執行。停止並繼續會重新啟動服務，可能中斷其他視窗或裝置上的工作。',
             operator_required: `目前無法從這裡更新背景服務。請透過 ${view.target.name} 上管理此服務的應用程式或命令更新，再重試。`,
@@ -53,6 +57,7 @@ export function formatHostHandoff(view, locale) {
         }
         : zh
             ? {
+                replacement_required: '当前尚未更新。选择继续后，将通过已安装的管理程序安全停止旧服务并启动选定版本；有活动工作时会另行确认。',
                 busy: '其它连接或正在执行的工作阻止了自动交接。停止并继续可能中断这些工作。',
                 activity_unknown: '后台服务与当前客户端不兼容，且无法确认有哪些工作仍在运行。停止并继续会重新启动服务，可能中断其他窗口或设备上的工作。',
                 operator_required: `目前无法从这里更新后台服务。请通过 ${view.target.name} 上管理此服务的应用或命令更新，然后重试。`,
@@ -60,6 +65,7 @@ export function formatHostHandoff(view, locale) {
                 retry_required: '服务状态发生了变化，或交接尚未完成。可以安全重试，不会默认中断工作。',
             }
             : {
+                replacement_required: 'No update is running. Continue to retire the old service through its installed operator and start the selected version. Interrupting active work requires a separate confirmation.',
                 busy: 'Other connections or work in progress prevent an automatic handoff. Stopping the service may interrupt that work.',
                 activity_unknown: 'The background service is incompatible with this client, and its active work is unknown. Stop and continue restarts it and may interrupt work in other windows or devices.',
                 operator_required: `This client cannot update the background service here. Use its managing app or operator command on ${view.target.name}, then retry.`,
@@ -89,6 +95,28 @@ export function formatHostHandoff(view, locale) {
             };
         descriptions.operator_required = guidance[view.recoveryBlocker];
     }
+    if (view.manualRecheck && view.reason === 'busy') {
+        descriptions.busy = zh
+            ? tw
+                ? '舊服務拒絕安全停止；這可能是其他連線或背景工作所致。關閉其他用戶端後可再次嘗試安全停止，或明確選擇中斷工作並繼續。'
+                : '旧服务拒绝安全停止；这可能是其他连接或后台工作所致。关闭其他客户端后可再次尝试安全停止，或明确选择中断工作并继续。'
+            : 'The old service refused safe retirement. Other connections or background work may be keeping it in use. Close other clients and try stopping safely again, or explicitly interrupt work and continue.';
+    }
+    if (view.manualRecheck && view.reason === 'operator_required') {
+        titles.operator_required = zh
+            ? tw
+                ? '無法連線到背景服務'
+                : '无法连接后台服务'
+            : 'Cannot connect to the background service';
+        descriptions.operator_required = zh
+            ? tw
+                ? '目前版本無法連線，且尚未執行更新。請查看診斷或更新用戶端，完成後重新檢查。'
+                : '当前版本无法连接，且尚未执行更新。请查看诊断或更新客户端，完成后重新检查。'
+            : 'These builds cannot connect and no update is running. Check the diagnostic or update the client, then recheck.';
+    }
+    const packageChange = view.packageChange
+        ? `${view.target.name}: ${view.packageChange.current} → ${view.packageChange.target}`
+        : '';
     const activity = view.activity;
     const background = activity?.drainResidencies;
     const backgroundFacts = !activity
@@ -111,17 +139,23 @@ export function formatHostHandoff(view, locale) {
                 ? `${activity.connections} 个连接 · ${activity.activeOperations} 个进行中的操作`
                 : `${activity.connections} connections · ${activity.activeOperations} operations in progress`
         : '';
-    const waiting = view.mayExitNaturally
-        ? tw
-            ? 'Maka 會持續檢查，並在可以安全繼續時自動繼續。'
-            : zh
-                ? 'Maka 会持续检查，并在可以安全继续时自动继续。'
-                : 'Maka keeps checking and continues automatically when it is safe.'
-        : tw
-            ? 'Maka 會持續檢查。若狀態沒有改變，等待或重試不會解決此問題。'
-            : zh
-                ? 'Maka 会持续检查。若状态没有变化，等待或重试不会解决此问题。'
-                : 'Maka keeps checking. Waiting or retrying will not resolve this unless the service state changes.';
+    const waiting = view.manualRecheck
+        ? zh
+            ? tw
+                ? '重新檢查只會重試連線，不會更新服務。'
+                : '重新检查只会重试连接，不会更新服务。'
+            : 'Recheck retries the connection without updating the service.'
+        : view.mayExitNaturally
+            ? tw
+                ? 'Maka 會持續檢查，並在可以安全繼續時自動繼續。'
+                : zh
+                    ? 'Maka 会持续检查，并在可以安全继续时自动继续。'
+                    : 'Maka keeps checking and continues automatically when it is safe.'
+            : tw
+                ? 'Maka 會持續檢查。若狀態沒有改變，等待或重試不會解決此問題。'
+                : zh
+                    ? 'Maka 会持续检查。若状态没有变化，等待或重试不会解决此问题。'
+                    : 'Maka keeps checking. Waiting or retrying will not resolve this unless the service state changes.';
     const repairNotice = view.operation === 'repair'
         ? tw
             ? '修復將使用目前應用程式配套的版本，可能替換現有服務版本。'
@@ -132,19 +166,34 @@ export function formatHostHandoff(view, locale) {
     const labels = tw
         ? {
             cancel: '取消',
-            retry: '安全重試',
-            interrupt: view.operation === 'repair' ? '中斷並修復' : '停止並繼續',
+            retry: view.manualRecheck ? '重新檢查' : '安全重試',
+            replace: '停止舊服務並繼續',
+            interrupt: view.manualRecheck
+                ? '中斷工作並繼續'
+                : view.operation === 'repair'
+                    ? '中斷並修復'
+                    : '停止並繼續',
         }
         : zh
             ? {
                 cancel: '取消',
-                retry: '安全重试',
-                interrupt: view.operation === 'repair' ? '中断并修复' : '停止并继续',
+                retry: view.manualRecheck ? '重新检查' : '安全重试',
+                replace: '停止旧服务并继续',
+                interrupt: view.manualRecheck
+                    ? '中断工作并继续'
+                    : view.operation === 'repair'
+                        ? '中断并修复'
+                        : '停止并继续',
             }
             : {
                 cancel: 'Cancel',
-                retry: 'Retry safely',
-                interrupt: view.operation === 'repair' ? 'Interrupt and repair' : 'Stop and continue',
+                retry: view.manualRecheck ? 'Recheck' : 'Retry safely',
+                replace: 'Stop old service and continue',
+                interrupt: view.manualRecheck
+                    ? 'Interrupt work and continue'
+                    : view.operation === 'repair'
+                        ? 'Interrupt and repair'
+                        : 'Stop and continue',
             };
     const phases = tw
         ? {
@@ -187,7 +236,7 @@ export function formatHostHandoff(view, locale) {
                 : zh
                     ? '正在完成交接或安全收尾，请稍候。'
                     : 'Finishing the handoff or its safe recovery. Please wait.'
-            : [facts, backgroundFacts, waiting, repairNotice, view.operatorStep]
+            : [packageChange, facts, backgroundFacts, waiting, repairNotice, view.operatorStep]
                 .filter(Boolean)
                 .join('\n'),
         actions: view.actions.map((action) => ({ action, label: labels[action] })),

package/node_modules/@maka/runtime-host/dist/client/host-handoff.js

@@ -55,6 +55,8 @@ export async function runHostHandoff(input) {
     // (or a broken successor) into an automatic replacement storm.
     const attempted = new Set();
     let automaticAttempts = 0;
+    let refusedWork;
+    let replacementCompleted = false;
     let recovery;
     const publish = (next) => {
         view = next;
@@ -102,7 +104,10 @@ export async function runHostHandoff(input) {
                         target: view.target,
                         reason: 'unavailable',
                         mayExitNaturally: false,
-                        diagnostic: boundedDiagnostic(error),
+                        ...(view.manualRecheck ? { manualRecheck: true } : {}),
+                        diagnostic: replacementCompleted
+                            ? `Host replacement completed, but reconnection failed: ${boundedDiagnostic(error)}`
+                            : boundedDiagnostic(error),
                     },
                 };
             }
@@ -124,11 +129,13 @@ export async function runHostHandoff(input) {
             const blocker = observed.blocker;
             if (recovery?.identity !== blocker.identity)
                 recovery = undefined;
+            if (refusedWork !== blocker.identity)
+                refusedWork = undefined;
             const nextSignature = blockerSignature(blocker);
             if (signature !== nextSignature) {
                 signature = nextSignature;
                 choice = undefined;
-                publish(projectBlocker(blocker, randomUUID(), recovery?.diagnostic));
+                publish(projectBlocker(blocker, randomUUID(), recovery?.diagnostic, refusedWork === blocker.identity));
             }
             const current = view;
             const selected = choice;
@@ -142,12 +149,19 @@ export async function runHostHandoff(input) {
             const automatic = !recovery &&
                 automaticAttempts < 3 &&
                 !attempted.has(nextSignature) &&
+                !blocker.replacement?.requiresExplicitSelection &&
                 blocker.replacement?.canReplaceIdle &&
                 blocker.activity &&
                 (isHostActivityIdle(blocker.activity) || cooperative);
             const interrupt = selected?.revision === current.revision && selected.action === 'interrupt';
+            const replace = selected?.revision === current.revision && selected.action === 'replace';
             const retry = selected?.revision === current.revision && selected.action === 'retry';
-            if ((automatic || interrupt || (retry && blocker.replacement?.canReplaceIdle)) &&
+            if ((automatic ||
+                interrupt ||
+                replace ||
+                (retry &&
+                    !blocker.replacement?.requiresExplicitSelection &&
+                    blocker.replacement?.canReplaceIdle)) &&
                 blocker.replacement) {
                 if (automatic) {
                     attempted.add(nextSignature);
@@ -179,6 +193,8 @@ export async function runHostHandoff(input) {
                 finally {
                     attemptAbort = undefined;
                 }
+                replacementCompleted = result.kind === 'completed';
+                refusedWork = result.kind === 'active_work' ? blocker.identity : undefined;
                 recovery =
                     result.kind === 'recovery_required'
                         ? { identity: blocker.identity, diagnostic: result.diagnostic.slice(0, 8_192) }
@@ -195,7 +211,7 @@ export async function runHostHandoff(input) {
                 signature = undefined;
                 continue;
             }
-            const attention = projectBlocker(blocker, current.revision, recovery?.diagnostic);
+            const attention = projectBlocker(blocker, current.revision, recovery?.diagnostic, refusedWork === blocker.identity);
             if (!input.openSurface)
                 throw new HostHandoffRequiredError(attention);
             surface ??= input.openSurface(submit);
@@ -211,7 +227,7 @@ export async function runHostHandoff(input) {
                         resolve();
                 };
                 const abort = () => finish(input.signal?.reason);
-                const timer = setTimeout(finish, interval);
+                const timer = blocker.manualRecheck ? undefined : setTimeout(finish, interval);
                 wake = () => finish();
                 input.signal?.addEventListener('abort', abort, { once: true });
                 if (input.signal?.aborted)
@@ -225,7 +241,7 @@ export async function runHostHandoff(input) {
         surface?.close();
     }
 }
-function projectBlocker(blocker, revision, recovery) {
+function projectBlocker(blocker, revision, recovery, activeWorkRefused = false) {
     const replacement = blocker.replacement;
     return {
         revision,
@@ -237,15 +253,30 @@ function projectBlocker(blocker, revision, recovery) {
                 ? 'repair_required'
                 : !replacement
                     ? 'operator_required'
-                    : !blocker.activity
-                        ? 'activity_unknown'
-                        : isHostActivityIdle(blocker.activity)
-                            ? 'retry_required'
-                            : 'busy',
+                    : replacement.requiresExplicitSelection
+                        ? activeWorkRefused
+                            ? 'busy'
+                            : 'replacement_required'
+                        : !blocker.activity
+                            ? 'activity_unknown'
+                            : isHostActivityIdle(blocker.activity)
+                                ? 'retry_required'
+                                : 'busy',
         ...(blocker.activity ? { activity: blocker.activity } : {}),
         mayExitNaturally: blocker.mayExitNaturally,
+        ...(blocker.manualRecheck ? { manualRecheck: true } : {}),
+        ...(blocker.packageChange ? { packageChange: blocker.packageChange } : {}),
         ...(replacement ? { operation: replacement.kind } : {}),
-        actions: replacement?.canInterrupt ? ['cancel', 'retry', 'interrupt'] : ['cancel', 'retry'],
+        actions: replacement?.requiresExplicitSelection
+            ? [
+                'cancel',
+                'retry',
+                'replace',
+                ...(activeWorkRefused && replacement.canInterrupt ? ['interrupt'] : []),
+            ]
+            : replacement?.canInterrupt
+                ? ['cancel', 'retry', 'interrupt']
+                : ['cancel', 'retry'],
         defaultAction: 'cancel',
         ...(blocker.recoveryBlocker ? { recoveryBlocker: blocker.recoveryBlocker } : {}),
         ...(blocker.operatorStep ? { operatorStep: blocker.operatorStep } : {}),
@@ -265,6 +296,9 @@ function blockerSignature(blocker) {
         blocker.replacement?.kind,
         blocker.replacement?.canReplaceIdle,
         blocker.replacement?.canInterrupt,
+        blocker.replacement?.requiresExplicitSelection,
+        blocker.manualRecheck,
+        blocker.packageChange,
         blocker.operatorStep,
         blocker.recoveryBlocker,
         blocker.diagnostic,

package/node_modules/@maka/runtime-host/dist/operator/setup-frame.js

@@ -41,6 +41,29 @@ const frameBase = {
     schemaVersion: z.literal(1),
     sequence: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
 };
+const environmentBindingFields = {
+    version: boundedString(128),
+    serviceId: z.string().regex(/^[a-f0-9]{64}$/u),
+    deploymentId: z.string().uuid(),
+    operator: z.unknown().transform((value, context) => {
+        try {
+            const command = decodeRuntimeHostOperatorCommand(value);
+            if (command.kind !== 'node') {
+                throw new Error('Runtime Host setup operator must be a Node command');
+            }
+            return command;
+        }
+        catch (error) {
+            context.addIssue({
+                code: 'custom',
+                message: error instanceof Error ? error.message : 'Runtime Host operator is invalid',
+            });
+            return z.NEVER;
+        }
+    }),
+    rootPath: boundedString(4 * 1024).refine((value) => !/[\u0000-\u001f\u007f]/u.test(value)),
+    rootId: z.string().regex(/^[a-f0-9]{64}$/u),
+};
 const SETUP_FRAME_SCHEMA = z.discriminatedUnion('kind', [
     z
         .object({
@@ -53,27 +76,7 @@ const SETUP_FRAME_SCHEMA = z.discriminatedUnion('kind', [
         .object({
         ...frameBase,
         kind: z.literal('complete'),
-        version: boundedString(128),
-        serviceId: z.string().regex(/^[a-f0-9]{64}$/u),
-        deploymentId: z.string().uuid(),
-        operator: z.unknown().transform((value, context) => {
-            try {
-                const command = decodeRuntimeHostOperatorCommand(value);
-                if (command.kind !== 'node') {
-                    throw new Error('Runtime Host setup operator must be a Node command');
-                }
-                return command;
-            }
-            catch (error) {
-                context.addIssue({
-                    code: 'custom',
-                    message: error instanceof Error ? error.message : 'Runtime Host operator is invalid',
-                });
-                return z.NEVER;
-            }
-        }),
-        rootPath: boundedString(4 * 1024).refine((value) => !/[\u0000-\u001f\u007f]/u.test(value)),
-        rootId: z.string().regex(/^[a-f0-9]{64}$/u),
+        ...environmentBindingFields,
         endpoint: boundedString(SETUP_FIELD_MAX_BYTES).refine((value) => parseRuntimeHostSetupEndpoint(value) !== undefined),
         credentialId: boundedString(SETUP_FIELD_MAX_BYTES),
         credential: boundedString(SETUP_CREDENTIAL_MAX_BYTES),
@@ -87,6 +90,13 @@ const SETUP_FRAME_SCHEMA = z.discriminatedUnion('kind', [
             .optional(),
     })
         .strict(),
+    z
+        .object({
+        ...frameBase,
+        kind: z.literal('existing_environment'),
+        ...environmentBindingFields,
+    })
+        .strict(),
     z
         .object({
         ...frameBase,

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

@@ -62,7 +62,15 @@ export const RUNTIME_HOST_REGISTRATION_SCHEMA_VERSION = 1;
 export const RUNTIME_HOST_PROTOCOL_VERSION = 0;
 // Increment when the same protocol version no longer guarantees safe Client-Host
 // interoperability. Mismatches are rejected before domain commands are admitted.
-export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 135;
+export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 141;
+// 141: WorkHub root admissions bind model Intent/Recall decisions before actions.
+// 140: Plugin Platform queries expose scoped Command contribution projections.
+// Epoch-139 peers reject the added query view and result shape.
+// 139: WorkHub recovery preserves the Host-authenticated Desktop capability binding.
+// 138: Removes the unused steering display anchor from canonical MessageContent.
+// 137: Reserved by the former display anchor contract.
+// 136: WorkHub transient proposals distinguish routing dispositions from linked
+// operations. Older peers expect replace/stop_work/resume_work dispositions.
 // 135: WorkHub model Turns replace direct action proposals with active-Turn task tools.
 // 134: Coordination actions own real Runtime Turns. Removes the synthetic record
 // operation, projects typed action receipts and admitted action identities, and