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

package/node_modules/@maka/runtime/dist/tool-output.js

@@ -47,9 +47,17 @@ function utf8Len(text) {
  * multi-byte sequence at the boundary with U+FFFD, which we strip.
  */
 function sliceLineByBytes(line, maxBytes, keep) {
-    const buf = Buffer.from(line, 'utf8');
-    if (buf.length <= maxBytes)
+    if (utf8Len(line) <= maxBytes)
         return line;
+    // One UTF-16 unit needs at least one UTF-8 byte. The extra unit keeps a
+    // surrogate pair crossing the window boundary outside the retained bytes.
+    // Preserve Buffer.subarray's original behavior for unusual numeric budgets.
+    const window = Number.isInteger(maxBytes) && maxBytes >= 0
+        ? keep === 'head'
+            ? line.slice(0, maxBytes + 1)
+            : line.slice(-(maxBytes + 1))
+        : line;
+    const buf = Buffer.from(window, 'utf8');
     const slice = keep === 'head' ? buf.subarray(0, maxBytes) : buf.subarray(buf.length - maxBytes);
     const decoded = slice.toString('utf8');
     return keep === 'head' ? decoded.replace(/�+$/, '') : decoded.replace(/^�+/, '');
@@ -68,33 +76,45 @@ export function truncateToolOutput(text, options = {}) {
     // A single trailing newline terminates the last line; it is not an extra
     // empty line, so it must not count against the line budget.
     const body = text.endsWith('\n') ? text.slice(0, -1) : text;
-    const lines = body.split('\n');
-    if (lines.length <= maxLines && totalBytes <= maxBytes) {
+    let lineCount = 1;
+    for (let index = body.indexOf('\n'); index !== -1; index = body.indexOf('\n', index + 1)) {
+        lineCount++;
+    }
+    if (lineCount <= maxLines && totalBytes <= maxBytes) {
         return { content: text, truncated: false, removed: 0, unit: 'lines' };
     }
     const out = [];
     let bytes = 0;
     let hitBytes = false;
     if (direction === 'head') {
-        for (let i = 0; i < lines.length && i < maxLines; i++) {
-            const size = utf8Len(lines[i]) + (i > 0 ? 1 : 0);
+        let start = 0;
+        for (let i = 0; i < lineCount && i < maxLines; i++) {
+            const newline = body.indexOf('\n', start);
+            const end = newline === -1 ? body.length : newline;
+            const line = body.slice(start, end);
+            const size = utf8Len(line) + (i > 0 ? 1 : 0);
             if (bytes + size > maxBytes) {
                 hitBytes = true;
                 break;
             }
-            out.push(lines[i]);
+            out.push(line);
             bytes += size;
+            start = end + 1;
         }
     }
     else {
-        for (let i = lines.length - 1; i >= 0 && out.length < maxLines; i--) {
-            const size = utf8Len(lines[i]) + (out.length > 0 ? 1 : 0);
+        let end = body.length;
+        for (let i = lineCount - 1; i >= 0 && out.length < maxLines; i--) {
+            const start = end > 0 ? body.lastIndexOf('\n', end - 1) + 1 : 0;
+            const line = body.slice(start, end);
+            const size = utf8Len(line) + (out.length > 0 ? 1 : 0);
             if (bytes + size > maxBytes) {
                 hitBytes = true;
                 break;
             }
-            out.unshift(lines[i]);
+            out.unshift(line);
             bytes += size;
+            end = start - 1;
         }
     }
     // The boundary line alone exceeds the byte budget. Rather than show only a
@@ -102,7 +122,10 @@ export function truncateToolOutput(text, options = {}) {
     // JSON/stack trace), keep a byte-safe slice of that line.
     let preview;
     if (out.length === 0) {
-        const line = direction === 'head' ? lines[0] : lines[lines.length - 1];
+        const firstNewline = body.indexOf('\n');
+        const line = direction === 'head'
+            ? body.slice(0, firstNewline === -1 ? body.length : firstNewline)
+            : body.slice(body.lastIndexOf('\n') + 1);
         preview = sliceLineByBytes(line, maxBytes, direction);
         bytes = utf8Len(preview);
         hitBytes = true;
@@ -110,7 +133,7 @@ export function truncateToolOutput(text, options = {}) {
     else {
         preview = out.join('\n');
     }
-    const removed = hitBytes ? Math.max(0, totalBytes - bytes) : lines.length - out.length;
+    const removed = hitBytes ? Math.max(0, totalBytes - bytes) : lineCount - out.length;
     if (removed <= 0) {
         // Nothing was actually dropped — e.g. content fits but a lone trailing
         // newline pushed totalBytes one over the byte budget. Don't emit a

package/node_modules/@maka/runtime/dist/unified-diff.js

@@ -58,19 +58,21 @@ export function createUnifiedDiff(path, oldContent, newContent) {
 export function createEditUnifiedDiff(path, oldContent, newContent, match) {
     if (oldContent.includes('\0') || newContent.includes('\0'))
         return undefined;
-    const oldLines = splitLines(oldContent);
-    const newLines = splitLines(newContent);
+    const oldLineCount = countLines(oldContent);
+    const newLineCount = countLines(newContent);
     const startIndex = match.startLine - 1;
     const oldEndIndex = match.endLine - 1;
-    if (startIndex < 0 || oldEndIndex < startIndex || oldEndIndex >= oldLines.length) {
+    if (startIndex < 0 || oldEndIndex < startIndex || oldEndIndex >= oldLineCount) {
         return undefined;
     }
     const windowStart = Math.max(0, startIndex - CONTEXT_LINES);
     const oldAfterStart = oldEndIndex + 1;
-    const newAfterStart = oldAfterStart + newLines.length - oldLines.length;
-    const oldWindow = oldLines.slice(windowStart, Math.min(oldLines.length, oldAfterStart + CONTEXT_LINES));
-    const newWindow = newLines.slice(windowStart, Math.min(newLines.length, Math.max(windowStart, newAfterStart) + CONTEXT_LINES));
-    if (isDiffWindowTooLarge(oldWindow) || isDiffWindowTooLarge(newWindow))
+    const newAfterStart = oldAfterStart + newLineCount - oldLineCount;
+    const oldWindow = readDiffWindow(oldContent, windowStart, Math.min(oldLineCount, oldAfterStart + CONTEXT_LINES));
+    if (!oldWindow)
+        return undefined;
+    const newWindow = readDiffWindow(newContent, windowStart, Math.min(newLineCount, Math.max(windowStart, newAfterStart) + CONTEXT_LINES));
+    if (!newWindow)
         return undefined;
     const ops = diffLines(oldWindow, newWindow);
     if (ops.every((op) => op.kind === 'keep'))
@@ -85,9 +87,6 @@ export function createEditUnifiedDiff(path, oldContent, newContent, match) {
 function isUndiffable(content) {
     return content.includes('\0') || Buffer.byteLength(content, 'utf8') > MAX_DIFF_SOURCE_BYTES;
 }
-function isDiffWindowTooLarge(lines) {
-    return lines.length > MAX_DIFF_SOURCE_LINES || isUndiffable(lines.join('\n'));
-}
 function splitLines(content) {
     const lines = content.split('\n');
     // A trailing newline terminates the last line rather than starting an empty
@@ -96,6 +95,37 @@ function splitLines(content) {
         lines.pop();
     return lines;
 }
+function countLines(content) {
+    let count = content.length > 0 && !content.endsWith('\n') ? 1 : 0;
+    for (let index = content.indexOf('\n'); index !== -1; index = content.indexOf('\n', index + 1)) {
+        count += 1;
+    }
+    return count;
+}
+/** Collect only the requested lines, failing before an oversized window is materialized. */
+function readDiffWindow(content, startLine, endLine) {
+    // Preserve Array.slice's fractional/NaN index normalization.
+    const from = Math.trunc(startLine) || 0;
+    const until = Math.trunc(endLine) || 0;
+    const lines = [];
+    let bytes = 0;
+    let offset = 0;
+    for (let lineIndex = 0; offset < content.length && lineIndex < until; lineIndex += 1) {
+        const newline = content.indexOf('\n', offset);
+        const end = newline === -1 ? content.length : newline;
+        if (lineIndex >= from) {
+            if (lines.length === MAX_DIFF_SOURCE_LINES)
+                return undefined;
+            const line = content.slice(offset, end);
+            bytes += Buffer.byteLength(line, 'utf8') + (lines.length > 0 ? 1 : 0);
+            if (bytes > MAX_DIFF_SOURCE_BYTES)
+                return undefined;
+            lines.push(line);
+        }
+        offset = end + 1;
+    }
+    return lines;
+}
 /** Line-level edit script via LCS dynamic programming, bounded by the caps above. */
 function diffLines(oldLines, newLines) {
     const n = oldLines.length;

package/node_modules/@maka/runtime/dist/web-fetch-tool.js

@@ -56,8 +56,10 @@ function truncateWebFetchOutput(content) {
     if (Buffer.byteLength(content, 'utf8') <= WEB_FETCH_MODEL_OUTPUT_MAX_BYTES)
         return content;
     const markerBytes = Buffer.byteLength(WEB_FETCH_TRUNCATION_MARKER, 'utf8');
-    const kept = Buffer.from(content, 'utf8')
-        .subarray(0, WEB_FETCH_MODEL_OUTPUT_MAX_BYTES - markerBytes)
+    const contentBytes = WEB_FETCH_MODEL_OUTPUT_MAX_BYTES - markerBytes;
+    // The extra UTF-16 unit keeps a split surrogate outside the retained bytes.
+    const kept = Buffer.from(content.slice(0, contentBytes + 1), 'utf8')
+        .subarray(0, contentBytes)
         .toString('utf8')
         .replace(/�+$/, '');
     return kept + WEB_FETCH_TRUNCATION_MARKER;

package/node_modules/@maka/runtime/dist/workers/filesystem-worker.js

@@ -830,8 +830,8 @@ function computeEditedSource(source, oldString, newString, where) {
   function finish(content, span, replacement, matchedVia) {
     const index = content.indexOf(span);
     const before = content.slice(0, index);
-    const startLine = before.split("\n").length;
-    const spanLineCount = span.split("\n").length - (span.endsWith("\n") ? 1 : 0);
+    const startLine = countOccurrences(before, "\n") + 1;
+    const spanLineCount = countOccurrences(span, "\n") + 1 - (span.endsWith("\n") ? 1 : 0);
     const endLine = startLine + Math.max(spanLineCount, 1) - 1;
     const next = before + replacement + content.slice(index + span.length);
     return { content: next, matchedVia, startLine, endLine };
@@ -941,6 +941,33 @@ function computeEditedSource(source, oldString, newString, where) {
   }
 }
 
+// src/text-line-window.ts
+function readTextLineWindow(content, offset, limit) {
+  if (offset === void 0 && limit === void 0) return content;
+  let lineCount = 1;
+  for (let cursor2 = content.indexOf("\n"); cursor2 !== -1; cursor2 = content.indexOf("\n", cursor2 + 1)) {
+    lineCount++;
+  }
+  const start = offset ?? 0;
+  const end = limit ? start + limit : lineCount;
+  const from = sliceIndex(start, lineCount);
+  const to = sliceIndex(end, lineCount);
+  if (from >= to) return "";
+  const selected = [];
+  let cursor = 0;
+  for (let line = 0; line < to; line++) {
+    const newline = content.indexOf("\n", cursor);
+    const lineEnd = newline === -1 ? content.length : newline;
+    if (line >= from) selected.push(content.slice(cursor, lineEnd));
+    cursor = lineEnd + 1;
+  }
+  return selected.join("\n");
+}
+function sliceIndex(value, length) {
+  const integer2 = Math.trunc(value) || 0;
+  return integer2 < 0 ? Math.max(length + integer2, 0) : Math.min(integer2, length);
+}
+
 // src/unified-diff.ts
 var MAX_DIFF_SOURCE_LINES = 800;
 var MAX_DIFF_SOURCE_BYTES = 32 * 1024;
@@ -960,25 +987,28 @@ function createUnifiedDiff(path2, oldContent, newContent) {
 }
 function createEditUnifiedDiff(path2, oldContent, newContent, match) {
   if (oldContent.includes("\0") || newContent.includes("\0")) return void 0;
-  const oldLines = splitLines(oldContent);
-  const newLines = splitLines(newContent);
+  const oldLineCount = countLines(oldContent);
+  const newLineCount = countLines(newContent);
   const startIndex = match.startLine - 1;
   const oldEndIndex = match.endLine - 1;
-  if (startIndex < 0 || oldEndIndex < startIndex || oldEndIndex >= oldLines.length) {
+  if (startIndex < 0 || oldEndIndex < startIndex || oldEndIndex >= oldLineCount) {
     return void 0;
   }
   const windowStart = Math.max(0, startIndex - CONTEXT_LINES);
   const oldAfterStart = oldEndIndex + 1;
-  const newAfterStart = oldAfterStart + newLines.length - oldLines.length;
-  const oldWindow = oldLines.slice(
+  const newAfterStart = oldAfterStart + newLineCount - oldLineCount;
+  const oldWindow = readDiffWindow(
+    oldContent,
     windowStart,
-    Math.min(oldLines.length, oldAfterStart + CONTEXT_LINES)
+    Math.min(oldLineCount, oldAfterStart + CONTEXT_LINES)
   );
-  const newWindow = newLines.slice(
+  if (!oldWindow) return void 0;
+  const newWindow = readDiffWindow(
+    newContent,
     windowStart,
-    Math.min(newLines.length, Math.max(windowStart, newAfterStart) + CONTEXT_LINES)
+    Math.min(newLineCount, Math.max(windowStart, newAfterStart) + CONTEXT_LINES)
   );
-  if (isDiffWindowTooLarge(oldWindow) || isDiffWindowTooLarge(newWindow)) return void 0;
+  if (!newWindow) return void 0;
   const ops = diffLines(oldWindow, newWindow);
   if (ops.every((op) => op.kind === "keep")) return void 0;
   const diff = [
@@ -991,14 +1021,38 @@ function createEditUnifiedDiff(path2, oldContent, newContent, match) {
 function isUndiffable(content) {
   return content.includes("\0") || Buffer.byteLength(content, "utf8") > MAX_DIFF_SOURCE_BYTES;
 }
-function isDiffWindowTooLarge(lines) {
-  return lines.length > MAX_DIFF_SOURCE_LINES || isUndiffable(lines.join("\n"));
-}
 function splitLines(content) {
   const lines = content.split("\n");
   if (lines.at(-1) === "") lines.pop();
   return lines;
 }
+function countLines(content) {
+  let count = content.length > 0 && !content.endsWith("\n") ? 1 : 0;
+  for (let index = content.indexOf("\n"); index !== -1; index = content.indexOf("\n", index + 1)) {
+    count += 1;
+  }
+  return count;
+}
+function readDiffWindow(content, startLine, endLine) {
+  const from = Math.trunc(startLine) || 0;
+  const until = Math.trunc(endLine) || 0;
+  const lines = [];
+  let bytes = 0;
+  let offset = 0;
+  for (let lineIndex = 0; offset < content.length && lineIndex < until; lineIndex += 1) {
+    const newline = content.indexOf("\n", offset);
+    const end = newline === -1 ? content.length : newline;
+    if (lineIndex >= from) {
+      if (lines.length === MAX_DIFF_SOURCE_LINES) return void 0;
+      const line = content.slice(offset, end);
+      bytes += Buffer.byteLength(line, "utf8") + (lines.length > 0 ? 1 : 0);
+      if (bytes > MAX_DIFF_SOURCE_BYTES) return void 0;
+      lines.push(line);
+    }
+    offset = end + 1;
+  }
+  return lines;
+}
 function diffLines(oldLines, newLines) {
   const n = oldLines.length;
   const m = newLines.length;
@@ -6747,8 +6801,6 @@ var memo = {
   attach(inst) {
     var _a3;
     let isRecursiveInst;
-    let lastCtx;
-    let lastBucket;
     (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
     inst._zod.deferred.push(() => {
       const base = inst._zod.parse;
@@ -6770,14 +6822,7 @@ var memo = {
           state = { buckets: /* @__PURE__ */ new Map(), backEdges: void 0 };
           ctx[STATE] = state;
         }
-        let bucket;
-        if (lastCtx === ctx) {
-          bucket = lastBucket;
-        } else {
-          bucket = bucketFor(state, inst);
-          lastCtx = ctx;
-          lastBucket = bucket;
-        }
+        const bucket = bucketFor(state, inst);
         const hit = bucket.get(input2);
         if (hit) {
           payload.value = hit.value;
@@ -6791,11 +6836,17 @@ var memo = {
           }
           return payload;
         }
+        const previousHandoff = handoff;
         handoff = bucket;
         const depth = open2.length;
-        const result = base(payload, ctx);
-        handoff = void 0;
-        const entry = open2.length > depth ? open2.pop() : void 0;
+        let result;
+        let entry;
+        try {
+          result = base(payload, ctx);
+        } finally {
+          handoff = previousHandoff;
+          entry = open2.length > depth ? open2.pop() : void 0;
+        }
         if (result instanceof Promise) {
           return result.then((r) => {
             if (entry)
@@ -20815,12 +20866,10 @@ async function executeFilesystemOperation(operation, operationBoundary, dependen
         }
       }
       const content = await fs3.readFile(path2, "utf8");
-      if (operation.offset === void 0 && operation.limit === void 0)
-        return { kind: "read", content };
-      const lines = content.split("\n");
-      const start = operation.offset ?? 0;
-      const end = operation.limit ? start + operation.limit : lines.length;
-      return { kind: "read", content: lines.slice(start, end).join("\n") };
+      return {
+        kind: "read",
+        content: readTextLineWindow(content, operation.offset, operation.limit)
+      };
     }
     case "write": {
       const path2 = await resolveWritableAllowed(

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

@@ -26,6 +26,7 @@ import { compareAndDeleteEntry, hostVisibilityAfterWrite, openStableTarget, writ
 import { promisify } from 'node:util';
 import { runProcessWithBoundedTail, runShellWithBoundedTail } from './shell-exec.js';
 import { isSupportedImagePath, readWorkspaceImage } from './image-file.js';
+import { readTextLineWindow } from './text-line-window.js';
 const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
 export const LOCAL_WORKSPACE_EXECUTOR_FACTS = {
@@ -65,12 +66,7 @@ export class LocalWorkspaceExecutor {
             return await readWorkspaceImage(input.path);
         }
         const content = await fs.readFile(input.path, 'utf8');
-        if (input.offset === undefined && input.limit === undefined)
-            return { content };
-        const lines = content.split('\n');
-        const start = input.offset ?? 0;
-        const end = input.limit ? start + input.limit : lines.length;
-        return { content: lines.slice(start, end).join('\n') };
+        return { content: readTextLineWindow(content, input.offset, input.limit) };
     }
     async writeFile(input) {
         await fs.writeFile(input.path, input.content, 'utf8');

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",
@@ -113,7 +131,8 @@
     "./tool-runtime": "./dist/tool-runtime.js",
     "./web-fetch-tool": "./dist/web-fetch-tool.js",
     "./web-search-tool": "./dist/web-search-tool.js",
-    "./xai-oauth-enrollment": "./dist/xai-oauth-enrollment.js"
+    "./xai-oauth-enrollment": "./dist/xai-oauth-enrollment.js",
+    "./session-import": "./dist/session-import.js"
   },
   "dependencies": {
     "@ai-sdk/anthropic": "4.0.46",

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,50 +48,75 @@ export function formatHostHandoff(view, locale) {
             };
     const descriptions = tw
         ? {
+            replacement_required: '目前尚未更新。選擇繼續後，將透過已安裝的管理程式安全停止舊服務並啟動選定版本；有進行中的工作時會另行確認。',
             busy: '其他連線或正在執行的工作阻止了自動交接。停止並繼續可能中斷這些工作。',
             activity_unknown: '背景服務與目前用戶端不相容，且無法確認有哪些工作仍在執行。停止並繼續會重新啟動服務，可能中斷其他視窗或裝置上的工作。',
             operator_required: `目前無法從這裡更新背景服務。請透過 ${view.target.name} 上管理此服務的應用程式或命令更新，再重試。`,
-            repair_required: '上次啟動或交接未能完成。可以安全重試；若仍失敗，請複製診斷資訊。',
+            repair_required: '上次啟動或交接失敗。請查看下方診斷資訊，修復原因後再重試；如果狀態沒有改變，重複重試通常不會解決問題。',
             retry_required: '服務狀態發生了變化，或交接尚未完成。可以安全重試，不會預設中斷工作。',
         }
         : zh
             ? {
+                replacement_required: '当前尚未更新。选择继续后，将通过已安装的管理程序安全停止旧服务并启动选定版本；有活动工作时会另行确认。',
                 busy: '其它连接或正在执行的工作阻止了自动交接。停止并继续可能中断这些工作。',
                 activity_unknown: '后台服务与当前客户端不兼容，且无法确认有哪些工作仍在运行。停止并继续会重新启动服务，可能中断其他窗口或设备上的工作。',
                 operator_required: `目前无法从这里更新后台服务。请通过 ${view.target.name} 上管理此服务的应用或命令更新，然后重试。`,
-                repair_required: '上次启动或交接未能完成。可以安全重试；若仍失败，请复制诊断信息。',
+                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 did not finish. Retry safely, or copy diagnostics if it still fails.',
+                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.',
             };
     if (view.recoveryBlocker && view.reason === 'operator_required') {
         const guidance = zh
             ? tw
                 ? {
-                    managed: '此背景服務由已安裝的管理程式維護。請在服務的管理應用程式中更新，再回到這裡重試。',
+                    managed: '此背景服務由安裝它的 Maka 管理。如果由 Desktop 安裝，請在該 Desktop 中開啟此工作區，然後選擇「停止舊服務並繼續」；否則請使用安裝它的 Maka 更新服務，再回到這裡重試。',
                     owner: '此背景服務屬於另一個 Maka 安裝。請使用管理它的 Maka 安裝更新，再重試。',
                     installation: '這次啟動使用暫存安裝，無法接管現有背景服務。請使用已安裝的 Maka 更新服務，再重試。',
                     identity: '無法確認舊背景服務的處理程序身分，因此不能安全停止它。請關閉啟動它的 Maka 或透過其管理程式停止服務，再重試。',
                 }
                 : {
-                    managed: '此后台服务由已安装的管理程序维护。请在服务的管理应用中更新，再回到这里重试。',
+                    managed: '此后台服务由安装它的 Maka 管理。如果由 Desktop 安装，请在该 Desktop 中打开此工作区，然后选择“停止旧服务并继续”；否则请使用安装它的 Maka 更新服务，再回到这里重试。',
                     owner: '此后台服务属于另一个 Maka 安装。请使用管理它的 Maka 安装更新，然后重试。',
                     installation: '本次启动使用临时安装，无法接管现有后台服务。请使用已安装的 Maka 更新服务，然后重试。',
                     identity: '无法确认旧后台服务的进程身份，因此不能安全停止它。请关闭启动它的 Maka 或通过其管理程序停止服务，然后重试。',
                 }
             : {
-                managed: 'An installed operator manages this background service. Update it through its managing app, then return here and retry.',
+                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];
     }
+    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] })),