maka-agent 0.2.0-dev.30.20260912 → 0.2.0-dev.31.20260913

package/node_modules/@maka/runtime/dist/workspace-executor.js

@@ -17,18 +17,20 @@
  * under the License.
  */
 import { promises as fs } from 'node:fs';
-import { exec, execFile } from 'node:child_process';
-import { glob as nodeGlob } from 'node:fs/promises';
+import { exec } from 'node:child_process';
+import { globFiles } from './glob-search.js';
 import { isAbsolute, resolve } from 'node:path';
 import { isPathInside, realpathAllowMissing, resolveCanonicalDirectoryEntryTarget, } from './path-containment.js';
 import { createPatchedFile, updatePatchedFile } from './apply-patch-file.js';
 import { compareAndDeleteEntry, hostVisibilityAfterWrite, openStableTarget, writeThroughHandle, } from './file-stable-write.js';
 import { promisify } from 'node:util';
+import { currentRipgrepEnvironment, RipgrepUnavailableError, ripgrepMissingOnPathMessage, } from './ripgrep-guidance.js';
 import { runProcessWithBoundedTail, runShellWithBoundedTail } from './shell-exec.js';
 import { isSupportedImagePath, readWorkspaceImage } from './image-file.js';
 import { readTextLineWindow } from './text-line-window.js';
+import { searchFiles } from './grep-search.js';
+import { defaultRipgrepCandidates, resolveRipgrepExecutable } from './ripgrep-executable.js';
 const execAsync = promisify(exec);
-const execFileAsync = promisify(execFile);
 export const LOCAL_WORKSPACE_EXECUTOR_FACTS = {
     isolation: 'none',
     writesAffectHost: true,
@@ -37,7 +39,11 @@ export const LOCAL_WORKSPACE_EXECUTOR_FACTS = {
     secrets: 'host_env',
 };
 export class LocalWorkspaceExecutor {
+    input;
     facts = LOCAL_WORKSPACE_EXECUTOR_FACTS;
+    constructor(input = {}) {
+        this.input = input;
+    }
     async exec(input) {
         const options = {
             cwd: input.cwd,
@@ -165,36 +171,26 @@ export class LocalWorkspaceExecutor {
         return { key: path };
     }
     async globFiles(input) {
-        const files = [];
-        const limit = input.limit ?? 200;
-        for await (const file of nodeGlob(input.pattern, { cwd: input.cwd })) {
-            files.push(typeof file === 'string' ? file : file.name);
-            if (files.length >= limit)
-                break;
-        }
-        return { files };
+        return globFiles(input);
     }
     async grepFiles(input) {
-        const args = ['-n', '--no-heading', `--max-count=${input.maxCountPerFile}`];
-        if (input.glob)
-            args.push('--glob', input.glob);
-        args.push('--', input.pattern, input.path);
+        const executable = await resolveRipgrepExecutable(this.input.rgCandidates ??
+            defaultRipgrepCandidates(this.input.hostEnv ?? process.env, this.input.platform ?? process.platform));
         try {
-            const { stdout } = await execFileAsync('rg', args, {
-                cwd: input.cwd,
-                maxBuffer: 5 * 1024 * 1024,
-                timeout: input.timeoutMs,
-                ...(input.abortSignal ? { signal: input.abortSignal } : {}),
-            });
-            return { matches: stdout.split('\n').filter(Boolean).slice(0, input.limit) };
+            return await searchFiles({ ...input, executable: executable ?? 'rg' });
         }
         catch (error) {
-            if (error?.code === 1)
-                return { matches: [] };
+            // Node reports a missing spawn cwd exactly like a missing executable
+            // (both `spawn rg ENOENT`), so only blame ripgrep once the cwd exists.
+            if (error?.code === 'ENOENT' && (await isDirectory(input.cwd)))
+                throw new RipgrepUnavailableError(ripgrepMissingOnPathMessage(currentRipgrepEnvironment()), { cause: error });
             throw error;
         }
     }
 }
+async function isDirectory(path) {
+    return await fs.stat(path).then((stat) => stat.isDirectory(), () => false);
+}
 export function createLocalWorkspaceExecutor() {
     return new LocalWorkspaceExecutor();
 }

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

@@ -8,6 +8,7 @@
     "./ask-user-question-tool": "./dist/ask-user-question-tool.js",
     "./ai-sdk-backend": "./dist/ai-sdk-backend.js",
     "./mcp-tools": "./dist/mcp-tools.js",
+    "./read-page": "./dist/read-page.js",
     "./builtin-tools": "./dist/builtin-tools.js",
     "./shell-tools": "./dist/shell-tools.js",
     "./shell-run-manager": "./dist/shell-run-manager.js",
@@ -154,6 +155,7 @@
     "@xterm/headless": "^6.0.0",
     "ai": "7.0.99",
     "ajv": "^8.20.0",
+    "glob": "^13.0.6",
     "https-proxy-agent": "^9.1.0",
     "image-dimensions": "^2.5.1",
     "linkedom": "^0.18.13",

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

@@ -16,103 +16,187 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-/** Shared consequence-oriented copy, not a second lifecycle policy. */
-export function formatHostHandoff(view, locale) {
-    const zh = locale !== 'en';
-    const tw = locale === 'zh-TW';
-    const titles = tw
-        ? {
+const COPY = {
+    'zh-CN': {
+        titles: {
+            replacement_required: '需要切换 WSL 后台服务',
+            busy: '后台服务仍在使用中',
+            activity_unknown: '需要确认是否停止后台服务',
+            operator_required: '后台服务需要手动更新',
+            repair_required: '后台服务需要修复',
+            retry_required: '暂时无法完成交接',
+        },
+        descriptions: (targetName) => ({
+            replacement_required: '当前尚未更新。选择继续后，将通过已安装的管理程序安全停止旧服务并启动选定版本；有活动工作时会另行确认。',
+            busy: '其它连接或正在执行的工作阻止了自动交接。停止并继续可能中断这些工作。',
+            activity_unknown: '后台服务与当前客户端不兼容，且无法确认有哪些工作仍在运行。停止并继续会重新启动服务，可能中断其他窗口或设备上的工作。',
+            operator_required: `目前无法从这里更新后台服务。请通过 ${targetName} 上管理此服务的应用或命令更新，然后重试。`,
+            repair_required: '上次启动或交接失败。请查看下方诊断信息，修复原因后再重试；如果状态没有变化，重复重试通常不会解决问题。',
+            retry_required: '服务状态发生了变化，或交接尚未完成。可以安全重试，不会默认中断工作。',
+        }),
+        recoveryGuidance: {
+            managed: '此后台服务由安装它的 Maka 管理。如果由 Desktop 安装，请在该 Desktop 中打开此工作区，然后选择“停止旧服务并继续”；否则请使用安装它的 Maka 更新服务，再回到这里重试。',
+            owner: '此后台服务属于另一个 Maka 安装。请使用管理它的 Maka 安装更新，然后重试。',
+            installation: '本次启动使用临时安装，无法接管现有后台服务。请使用已安装的 Maka 更新服务，然后重试。',
+            identity: '无法确认旧后台服务的进程身份，因此不能安全停止它。请关闭启动它的 Maka 或通过其管理程序停止服务，然后重试。',
+        },
+        manualBusy: '旧服务拒绝安全停止；这可能是其他连接或后台工作所致。关闭其他客户端后可再次尝试安全停止，或明确选择中断工作并继续。',
+        manualOperatorTitle: '无法连接后台服务',
+        manualOperatorDescription: '当前版本无法连接，且尚未执行更新。请查看诊断或更新客户端，完成后重新检查。',
+        activity: (connections, operations) => `${connections} 个连接 · ${operations} 个进行中的操作`,
+        background: (count) => `${count} 个后台工作`,
+        backgroundUnknown: '后台工作数量未知',
+        waiting: {
+            recheck: '重新检查只会重试连接，不会更新服务。',
+            natural: 'Maka 会持续检查，并在可以安全继续时自动继续。',
+            blocked: 'Maka 会持续检查。若状态没有变化，等待或重试不会解决此问题。',
+        },
+        repairNotice: '修复将使用当前应用配套的版本，可能替换现有服务版本。',
+        labels: {
+            cancel: '取消',
+            retry: '安全重试',
+            recheck: '重新检查',
+            replace: '停止旧服务并继续',
+            interrupt: '停止并继续',
+            interruptRepair: '中断并修复',
+            interruptRecheck: '中断工作并继续',
+        },
+        phases: {
+            checking: '正在检查服务',
+            staging: '正在准备更新',
+            pausing: '正在等待安全暂停点',
+            retiring: '正在停止旧服务',
+            replacing: '正在替换服务',
+            verifying: '正在确认工作区已就绪',
+        },
+        progressTitle: '正在继续打开工作区',
+        progressDetail: '正在完成交接或安全收尾，请稍候。',
+    },
+    'zh-TW': {
+        titles: {
             replacement_required: '需要切換 WSL 背景服務',
             busy: '背景服務仍在使用中',
             activity_unknown: '需要確認是否停止背景服務',
             operator_required: '背景服務需要手動更新',
             repair_required: '背景服務需要修復',
             retry_required: '暫時無法完成交接',
-        }
-        : zh
-            ? {
-                replacement_required: '需要切换 WSL 后台服务',
-                busy: '后台服务仍在使用中',
-                activity_unknown: '需要确认是否停止后台服务',
-                operator_required: '后台服务需要手动更新',
-                repair_required: '后台服务需要修复',
-                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',
-                repair_required: 'Your background service needs repair',
-                retry_required: 'The handoff could not finish yet',
-            };
-    const descriptions = tw
-        ? {
+        },
+        descriptions: (targetName) => ({
             replacement_required: '目前尚未更新。選擇繼續後，將透過已安裝的管理程式安全停止舊服務並啟動選定版本；有進行中的工作時會另行確認。',
             busy: '其他連線或正在執行的工作阻止了自動交接。停止並繼續可能中斷這些工作。',
             activity_unknown: '背景服務與目前用戶端不相容，且無法確認有哪些工作仍在執行。停止並繼續會重新啟動服務，可能中斷其他視窗或裝置上的工作。',
-            operator_required: `目前無法從這裡更新背景服務。請透過 ${view.target.name} 上管理此服務的應用程式或命令更新，再重試。`,
+            operator_required: `目前無法從這裡更新背景服務。請透過 ${targetName} 上管理此服務的應用程式或命令更新，再重試。`,
             repair_required: '上次啟動或交接失敗。請查看下方診斷資訊，修復原因後再重試；如果狀態沒有改變，重複重試通常不會解決問題。',
             retry_required: '服務狀態發生了變化，或交接尚未完成。可以安全重試，不會預設中斷工作。',
-        }
-        : zh
-            ? {
-                replacement_required: '当前尚未更新。选择继续后，将通过已安装的管理程序安全停止旧服务并启动选定版本；有活动工作时会另行确认。',
-                busy: '其它连接或正在执行的工作阻止了自动交接。停止并继续可能中断这些工作。',
-                activity_unknown: '后台服务与当前客户端不兼容，且无法确认有哪些工作仍在运行。停止并继续会重新启动服务，可能中断其他窗口或设备上的工作。',
-                operator_required: `目前无法从这里更新后台服务。请通过 ${view.target.name} 上管理此服务的应用或命令更新，然后重试。`,
-                repair_required: '上次启动或交接失败。请查看下方诊断信息，修复原因后再重试；如果状态没有变化，重复重试通常不会解决问题。',
-                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.`,
-                repair_required: 'The last startup or handoff failed. Review the diagnostic below, correct the cause, then retry. Repeating the same action without a state change will usually fail again.',
-                retry_required: 'The service changed or the handoff has not finished. A safe retry will not interrupt work by default.',
-            };
+        }),
+        recoveryGuidance: {
+            managed: '此背景服務由安裝它的 Maka 管理。如果由 Desktop 安裝，請在該 Desktop 中開啟此工作區，然後選擇「停止舊服務並繼續」；否則請使用安裝它的 Maka 更新服務，再回到這裡重試。',
+            owner: '此背景服務屬於另一個 Maka 安裝。請使用管理它的 Maka 安裝更新，再重試。',
+            installation: '這次啟動使用暫存安裝，無法接管現有背景服務。請使用已安裝的 Maka 更新服務，再重試。',
+            identity: '無法確認舊背景服務的處理程序身分，因此不能安全停止它。請關閉啟動它的 Maka 或透過其管理程式停止服務，再重試。',
+        },
+        manualBusy: '舊服務拒絕安全停止；這可能是其他連線或背景工作所致。關閉其他用戶端後可再次嘗試安全停止，或明確選擇中斷工作並繼續。',
+        manualOperatorTitle: '無法連線到背景服務',
+        manualOperatorDescription: '目前版本無法連線，且尚未執行更新。請查看診斷或更新用戶端，完成後重新檢查。',
+        activity: (connections, operations) => `${connections} 個連線 · ${operations} 個進行中的操作`,
+        background: (count) => `${count} 個背景工作`,
+        backgroundUnknown: '背景工作數量未知',
+        waiting: {
+            recheck: '重新檢查只會重試連線，不會更新服務。',
+            natural: 'Maka 會持續檢查，並在可以安全繼續時自動繼續。',
+            blocked: 'Maka 會持續檢查。若狀態沒有改變，等待或重試不會解決此問題。',
+        },
+        repairNotice: '修復將使用目前應用程式配套的版本，可能替換現有服務版本。',
+        labels: {
+            cancel: '取消',
+            retry: '安全重試',
+            recheck: '重新檢查',
+            replace: '停止舊服務並繼續',
+            interrupt: '停止並繼續',
+            interruptRepair: '中斷並修復',
+            interruptRecheck: '中斷工作並繼續',
+        },
+        phases: {
+            checking: '正在檢查服務',
+            staging: '正在準備更新',
+            pausing: '正在等待安全暫停點',
+            retiring: '正在停止舊服務',
+            replacing: '正在替換服務',
+            verifying: '正在確認工作區已就緒',
+        },
+        progressTitle: '正在繼續開啟工作區',
+        progressDetail: '正在完成交接或安全收尾，請稍候。',
+    },
+    en: {
+        titles: {
+            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',
+            repair_required: 'Your background service needs repair',
+            retry_required: 'The handoff could not finish yet',
+        },
+        descriptions: (targetName) => ({
+            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 ${targetName}, then retry.`,
+            repair_required: 'The last startup or handoff failed. Review the diagnostic below, correct the cause, then retry. Repeating the same action without a state change will usually fail again.',
+            retry_required: 'The service changed or the handoff has not finished. A safe retry will not interrupt work by default.',
+        }),
+        recoveryGuidance: {
+            managed: 'This background service is managed by the Maka installation that created it. If Desktop installed it, open this workspace there and choose Stop old service and continue. Otherwise update the service with that Maka installation, then return here and retry.',
+            owner: 'Another Maka installation owns this background service. Update it using that installation, then retry.',
+            installation: 'This temporary installation cannot take over the existing background service. Update it using an installed Maka, then retry.',
+            identity: 'The old background process could not be identified safely. Close the Maka instance that started it or stop it through its operator, then retry.',
+        },
+        manualBusy: '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.',
+        manualOperatorTitle: 'Cannot connect to the background service',
+        manualOperatorDescription: 'These builds cannot connect and no update is running. Check the diagnostic or update the client, then recheck.',
+        activity: (connections, operations) => `${connections} connections · ${operations} operations in progress`,
+        background: (count) => `${count} background activities`,
+        backgroundUnknown: 'Background activity count unknown',
+        waiting: {
+            recheck: 'Recheck retries the connection without updating the service.',
+            natural: 'Maka keeps checking and continues automatically when it is safe.',
+            blocked: 'Maka keeps checking. Waiting or retrying will not resolve this unless the service state changes.',
+        },
+        repairNotice: 'Repair uses the version supplied with this app and may replace the installed service version.',
+        labels: {
+            cancel: 'Cancel',
+            retry: 'Retry safely',
+            recheck: 'Recheck',
+            replace: 'Stop old service and continue',
+            interrupt: 'Stop and continue',
+            interruptRepair: 'Interrupt and repair',
+            interruptRecheck: 'Interrupt work and continue',
+        },
+        phases: {
+            checking: 'Checking the service',
+            staging: 'Preparing the update',
+            pausing: 'Waiting for a safe pause point',
+            retiring: 'Stopping the previous service',
+            replacing: 'Replacing the service',
+            verifying: 'Verifying your workspace is ready',
+        },
+        progressTitle: 'Continuing to your workspace',
+        progressDetail: 'Finishing the handoff or its safe recovery. Please wait.',
+    },
+};
+/** Shared consequence-oriented copy, not a second lifecycle policy. */
+export function formatHostHandoff(view, locale) {
+    const copy = COPY[locale];
+    let title = copy.titles[view.reason];
+    let description = copy.descriptions(view.target.name)[view.reason];
     if (view.recoveryBlocker && view.reason === 'operator_required') {
-        const guidance = zh
-            ? tw
-                ? {
-                    managed: '此背景服務由安裝它的 Maka 管理。如果由 Desktop 安裝，請在該 Desktop 中開啟此工作區，然後選擇「停止舊服務並繼續」；否則請使用安裝它的 Maka 更新服務，再回到這裡重試。',
-                    owner: '此背景服務屬於另一個 Maka 安裝。請使用管理它的 Maka 安裝更新，再重試。',
-                    installation: '這次啟動使用暫存安裝，無法接管現有背景服務。請使用已安裝的 Maka 更新服務，再重試。',
-                    identity: '無法確認舊背景服務的處理程序身分，因此不能安全停止它。請關閉啟動它的 Maka 或透過其管理程式停止服務，再重試。',
-                }
-                : {
-                    managed: '此后台服务由安装它的 Maka 管理。如果由 Desktop 安装，请在该 Desktop 中打开此工作区，然后选择“停止旧服务并继续”；否则请使用安装它的 Maka 更新服务，再回到这里重试。',
-                    owner: '此后台服务属于另一个 Maka 安装。请使用管理它的 Maka 安装更新，然后重试。',
-                    installation: '本次启动使用临时安装，无法接管现有后台服务。请使用已安装的 Maka 更新服务，然后重试。',
-                    identity: '无法确认旧后台服务的进程身份，因此不能安全停止它。请关闭启动它的 Maka 或通过其管理程序停止服务，然后重试。',
-                }
-            : {
-                managed: 'This background service is managed by the Maka installation that created it. If Desktop installed it, open this workspace there and choose Stop old service and continue. Otherwise update the service with that Maka installation, then return here and retry.',
-                owner: 'Another Maka installation owns this background service. Update it using that installation, then retry.',
-                installation: 'This temporary installation cannot take over the existing background service. Update it using an installed Maka, then retry.',
-                identity: 'The old background process could not be identified safely. Close the Maka instance that started it or stop it through its operator, then retry.',
-            };
-        descriptions.operator_required = guidance[view.recoveryBlocker];
+        description = copy.recoveryGuidance[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.';
+        description = copy.manualBusy;
     }
     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.';
+        title = copy.manualOperatorTitle;
+        description = copy.manualOperatorDescription;
     }
     const packageChange = view.packageChange
         ? `${view.target.name}: ${view.packageChange.current} → ${view.packageChange.target}`
@@ -122,120 +206,30 @@ export function formatHostHandoff(view, locale) {
     const backgroundFacts = !activity
         ? ''
         : background !== undefined
-            ? tw
-                ? `${background} 個背景工作`
-                : zh
-                    ? `${background} 个后台工作`
-                    : `${background} background activities`
-            : tw
-                ? '背景工作數量未知'
-                : zh
-                    ? '后台工作数量未知'
-                    : 'Background activity count unknown';
-    const facts = activity
-        ? tw
-            ? `${activity.connections} 個連線 · ${activity.activeOperations} 個進行中的操作`
-            : zh
-                ? `${activity.connections} 个连接 · ${activity.activeOperations} 个进行中的操作`
-                : `${activity.connections} connections · ${activity.activeOperations} operations in progress`
-        : '';
+            ? copy.background(background)
+            : copy.backgroundUnknown;
+    const facts = activity ? copy.activity(activity.connections, activity.activeOperations) : '';
     const waiting = view.manualRecheck
-        ? zh
-            ? tw
-                ? '重新檢查只會重試連線，不會更新服務。'
-                : '重新检查只会重试连接，不会更新服务。'
-            : 'Recheck retries the connection without updating the service.'
+        ? copy.waiting.recheck
         : 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
-            ? '修復將使用目前應用程式配套的版本，可能替換現有服務版本。'
-            : zh
-                ? '修复将使用当前应用配套的版本，可能替换现有服务版本。'
-                : 'Repair uses the version supplied with this app and may replace the installed service version.'
-        : '';
-    const labels = tw
-        ? {
-            cancel: '取消',
-            retry: view.manualRecheck ? '重新檢查' : '安全重試',
-            replace: '停止舊服務並繼續',
-            interrupt: view.manualRecheck
-                ? '中斷工作並繼續'
-                : view.operation === 'repair'
-                    ? '中斷並修復'
-                    : '停止並繼續',
-        }
-        : zh
-            ? {
-                cancel: '取消',
-                retry: view.manualRecheck ? '重新检查' : '安全重试',
-                replace: '停止旧服务并继续',
-                interrupt: view.manualRecheck
-                    ? '中断工作并继续'
-                    : view.operation === 'repair'
-                        ? '中断并修复'
-                        : '停止并继续',
-            }
-            : {
-                cancel: 'Cancel',
-                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
-        ? {
-            checking: '正在檢查服務',
-            staging: '正在準備更新',
-            pausing: '正在等待安全暫停點',
-            retiring: '正在停止舊服務',
-            replacing: '正在替換服務',
-            verifying: '正在確認工作區已就緒',
-        }
-        : zh
-            ? {
-                checking: '正在检查服务',
-                staging: '正在准备更新',
-                pausing: '正在等待安全暂停点',
-                retiring: '正在停止旧服务',
-                replacing: '正在替换服务',
-                verifying: '正在确认工作区已就绪',
-            }
-            : {
-                checking: 'Checking the service',
-                staging: 'Preparing the update',
-                pausing: 'Waiting for a safe pause point',
-                retiring: 'Stopping the previous service',
-                replacing: 'Replacing the service',
-                verifying: 'Verifying your workspace is ready',
-            };
+            ? copy.waiting.natural
+            : copy.waiting.blocked;
+    const repairNotice = view.operation === 'repair' ? copy.repairNotice : '';
+    const labels = {
+        cancel: copy.labels.cancel,
+        retry: view.manualRecheck ? copy.labels.recheck : copy.labels.retry,
+        replace: copy.labels.replace,
+        interrupt: view.manualRecheck
+            ? copy.labels.interruptRecheck
+            : view.operation === 'repair'
+                ? copy.labels.interruptRepair
+                : copy.labels.interrupt,
+    };
     return {
-        title: view.state === 'progress'
-            ? tw
-                ? '正在繼續開啟工作區'
-                : zh
-                    ? '正在继续打开工作区'
-                    : 'Continuing to your workspace'
-            : titles[view.reason],
-        description: view.state === 'progress' ? phases[view.phase ?? 'checking'] : descriptions[view.reason],
+        title: view.state === 'progress' ? copy.progressTitle : title,
+        description: view.state === 'progress' ? copy.phases[view.phase ?? 'checking'] : description,
         detail: view.state === 'progress'
-            ? tw
-                ? '正在完成交接或安全收尾，請稍候。'
-                : zh
-                    ? '正在完成交接或安全收尾，请稍候。'
-                    : 'Finishing the handoff or its safe recovery. Please wait.'
+            ? copy.progressDetail
             : [packageChange, facts, backgroundFacts, waiting, repairNotice, view.operatorStep]
                 .filter(Boolean)
                 .join('\n'),

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

@@ -139,6 +139,9 @@ class RuntimeHostReconnectingConnectionImpl {
             }
         }
     }
+    openSessionSubscriptionOnce(input, timeoutMs) {
+        return this.#requireCurrent('subscription.open').openSessionSubscription(input, timeoutMs);
+    }
     async replaceClientCapabilities(provider, timeoutMs) {
         const connection = this.#requireCurrent('client.capability.replace');
         return connection.replaceClientCapabilities(provider, timeoutMs);

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

@@ -62,7 +62,11 @@ 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 = 149;
+export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 151;
+// 151: WorkHub selects and delegates through a durable Host Form interaction.
+// 150: Message admission accepts an empty-text Message that carries a quote or
+// an attachment (#4804). Peers older than this epoch reject that frame at
+// admission, so the pair must refuse each other at the handshake.
 // 149: Connection model overrides retain disabled identities and separate capacity
 // from compaction. Catalog entries carry overrides; clients do not rebuild them.
 // 148: Model catalog entries include image support before a user override.

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

@@ -19,7 +19,7 @@
 import { invalidProtocolFrame } from './errors.js';
 import { assertExactKeys, requireCount, requireEntityId, requireExactRecord, requireId, requireRecord, requireShapedRecord, requireUtf8String, } from './codec.js';
 import { defineOperation } from './operation-spec.js';
-import { decodeMessageContent, decodeMessageAdmissionContent, decodeSkillIds, decodeTurnOrchestration, decodeTurnSnapshot, TURN_MESSAGE_TEXT_MAX_BYTES, } from './turn.js';
+import { decodeMessageAdmissionContent, decodeSkillIds, decodeTurnOrchestration, decodeTurnSnapshot, TURN_MESSAGE_TEXT_MAX_BYTES, } from './turn.js';
 import { decodeSkillInvocationResult } from '@maka/core/skill-invocation';
 export const MESSAGE_QUEUE_MAX_ENTRIES = 64;
 export const MESSAGE_QUEUE_PROJECTION_MAX_BYTES = 52 * 1024;
@@ -432,7 +432,7 @@ function decodeMessageQueueEntrySnapshot(value) {
     const base = {
         entryId: requireEntityId(record.entryId, 'entryId'),
         messageId: requireEntityId(record.messageId, 'messageId'),
-        content: decodeMessageContent(record.content),
+        content: decodeMessageAdmissionContent(record.content),
         placement: requireMessagePlacement(record.placement),
     };
     if (record.state === 'queued' || record.state === 'retracted') {

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

@@ -222,6 +222,7 @@ export const REMOTE_OWNER_OPERATION_GRANTS = Object.freeze([
     'web-search.execute',
     'workhub.coordination.answer',
     'workhub.coordination.actFromTurn',
+    'workhub.coordination.selectAndDelegate',
     'workhub.coordination.candidates',
     'workhub.coordination.configureModel',
     'workhub.coordination.query',

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

@@ -24,7 +24,7 @@ import { decodeSessionStatus } from './session-status.js';
 import { decodeSessionInteractionProjection, } from './interaction.js';
 import { decodeSessionMessageQueueProjection, } from './message.js';
 import { defineOperation } from './operation-spec.js';
-import { decodeMessageContent, decodeTurnSnapshot, } from './turn.js';
+import { decodeMessageAdmissionContent, decodeTurnSnapshot, } from './turn.js';
 import { decodeGoalProjection } from './goal.js';
 import { decodeRuntimeResourceRef } from './runtime-resource.js';
 import { decodeSessionTranscriptBootstrap, SESSION_TRANSCRIPT_BOOTSTRAP_MAX_BYTES, } from './session-transcript.js';
@@ -510,7 +510,7 @@ function decodeSessionSteeringEvent(record) {
         turnId: requireEntityId(record.turnId, 'turnId'),
         ts: requireCount(record.ts, 'Session steering event timestamp'),
         messageId: requireEntityId(record.messageId, 'messageId'),
-        content: decodeMessageContent(record.content),
+        content: decodeMessageAdmissionContent(record.content),
     };
 }
 function decodeSessionToolEvent(value) {

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

@@ -17,7 +17,7 @@
  * under the License.
  */
 import { MAX_ATTACHMENT_BYTES, MAX_ATTACHMENT_COUNT } from '@maka/core/attachments';
-import { decodeMessageContent as decodeCanonicalMessageContent, DIRECTORY_REFERENCE_MAX_COUNT, isCanonicalAttachmentRef, } from '@maka/core/events';
+import { decodeMessageContent as decodeCanonicalMessageContent, DIRECTORY_REFERENCE_MAX_COUNT, hasMeaningfulMessageContent, isCanonicalAttachmentRef, } from '@maka/core/events';
 import { isOrchestrationMode, isTurnOrchestrationSource, } from '@maka/core/orchestration';
 import { decodeSkillInvocationResult, } from '@maka/core/skill-invocation';
 import { invalidProtocolFrame } from './errors.js';
@@ -268,7 +268,15 @@ export function decodeMessageContent(value, allowEmptyText = false) {
 }
 /** Client-authored Messages cannot claim Host-owned Session context references. */
 export function decodeMessageAdmissionContent(value, allowEmptyText = false) {
-    const content = decodeMessageContent(value, allowEmptyText);
+    // Structure first with text emptiness unconstrained, then apply the
+    // shared meaningful-content predicate: a quote or an attachment carries
+    // the turn by itself, so empty inline text is admissible when either is
+    // present (#4804). A truly contentless Message still throws, with the
+    // same frame error the text-length rule produced.
+    const content = decodeMessageContent(value, true);
+    if (!allowEmptyText && !hasMeaningfulMessageContent(content)) {
+        throw invalidProtocolFrame('Invalid Message text');
+    }
     if (content.attachments?.some((attachment) => attachment.ref.kind === 'session_context')) {
         throw invalidProtocolFrame('Session context references are Host-owned');
     }