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

package/dist/runtime-host-tui-owner.js

@@ -0,0 +1,226 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { randomUUID } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+import { formatUiMessage } from '@maka/core/ui-locale';
+import { connectExistingRuntimeHost, } from '@maka/runtime-host/client';
+import { readLocalHostDeploymentRecord, resolveRuntimeHostManagedDeploymentAuthority, withLocalHostDeploymentAuthority, } from '@maka/runtime-host/operator';
+import { isProductReleaseVersion } from '@maka/runtime-host/operator/update-package-evidence';
+import { INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID, RUNTIME_HOST_PROTOCOL_VERSION, } from '@maka/runtime-host/protocol';
+import { resolveRuntimeHostNpmGlobalInstallation } from './runtime-host-cli-installation.js';
+import { runRuntimeHostInstalledUpdateBootstrap } from './runtime-host-installed-update-bootstrap.js';
+import { retireRuntimeHostLifecycleOwner } from './runtime-host-lifecycle-transaction.js';
+import { openRuntimeHostNpmGlobalStagedDeployment } from './runtime-host-local-handoff.js';
+import { launchRuntimeHostTargetActivator } from './runtime-host-local-target-activation.js';
+import { getTuiHostOwnerCopy } from './tui-host-owner-copy.js';
+/** A thin owner adapter. The caller disconnects its reconnecting client before execute. */
+export async function prepareTuiHostOwnerAction(input, overrides = {}) {
+    const locale = input.locale ?? 'en';
+    const copy = getTuiHostOwnerCopy(locale);
+    if (input.profile.kind !== 'local') {
+        throw new Error(copy.foreign);
+    }
+    const deps = {
+        resolveInstallation: resolveRuntimeHostNpmGlobalInstallation,
+        readRecord: readLocalHostDeploymentRecord,
+        resolveManagedAuthority: resolveRuntimeHostManagedDeploymentAuthority,
+        connectExisting: connectExistingRuntimeHost,
+        withAuthority: withLocalHostDeploymentAuthority,
+        retire: retireRuntimeHostLifecycleOwner,
+        openStaged: openRuntimeHostNpmGlobalStagedDeployment,
+        activate: launchRuntimeHostTargetActivator,
+        update: runRuntimeHostInstalledUpdateBootstrap,
+        ...overrides,
+    };
+    const installation = await deps.resolveInstallation();
+    const rootId = input.connection.rootId;
+    const hostEpoch = input.connection.hostEpoch;
+    if (await deps.resolveManagedAuthority(rootId))
+        throw new Error(copy.notOwner);
+    const record = await deps.readRecord(rootId);
+    if (record?.state.kind !== 'owned' ||
+        record.state.owner.kind !== 'cli' ||
+        record.state.owner.installationId !== installation.owner.installationId) {
+        throw new Error(copy.notOwner);
+    }
+    const observed = await deps.connectExisting({
+        rootPath: input.rootPath,
+        protocol: { min: RUNTIME_HOST_PROTOCOL_VERSION, max: RUNTIME_HOST_PROTOCOL_VERSION },
+        compositionId: INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID,
+    });
+    try {
+        if (observed.kind !== 'connected' ||
+            observed.registration.rootId !== rootId ||
+            observed.registration.hostEpoch !== hostEpoch ||
+            observed.registration.lifecycleMode !== 'ephemeral') {
+            throw new Error(copy.hostChanged);
+        }
+    }
+    finally {
+        if (observed.kind === 'connected')
+            await observed.connection.close();
+    }
+    const diagnostics = await input.connection
+        .request('host.diagnostics.query', {})
+        .catch(() => undefined);
+    const fingerprint = activityFingerprint(diagnostics);
+    let allowInterruptActiveTasks = false;
+    if (!diagnostics || diagnostics.upgradeBlockingActivity) {
+        const choice = await input.confirm([
+            formatUiMessage(copy.actionSummary, { action: copy[`action_${input.action.action}`], name: input.profile.name }, locale),
+            formatUiMessage(copy.owner, { owner: installation.owner.installationId }, locale),
+            formatUiMessage(copy.root, { root: rootId }, locale),
+            formatUiMessage(copy.epoch, { epoch: hostEpoch }, locale),
+            diagnostics
+                ? formatUiMessage(copy.activity, {
+                    connections: diagnostics.connections,
+                    operations: diagnostics.activeOperations,
+                    residencies: JSON.stringify(diagnostics.residencies),
+                }, locale)
+                : copy.unknownActivity,
+            input.action.action === 'update' ? copy.updateSafeOnly : '',
+        ]
+            .filter(Boolean)
+            .join('\n'));
+        if (choice === 'cancel')
+            return undefined;
+        allowInterruptActiveTasks = choice === 'interrupt';
+    }
+    const target = input.action.target ?? 'latest';
+    if (input.action.action === 'update' &&
+        target !== 'latest' &&
+        target !== 'next' &&
+        !isProductReleaseVersion(target))
+        throw new Error(copy.invalidTarget);
+    if (input.action.action === 'update' && allowInterruptActiveTasks) {
+        throw new Error(copy.updateRequiresSafe);
+    }
+    return async () => {
+        if (!isDeepStrictEqual(await deps.resolveInstallation(), installation)) {
+            throw new Error(copy.installationChanged);
+        }
+        if (input.action.action === 'update') {
+            if (await deps.resolveManagedAuthority(rootId))
+                throw new Error(copy.notOwner);
+            return deps.update({
+                rootPath: input.rootPath,
+                selector: target === 'latest' || target === 'next'
+                    ? { kind: 'channel', channel: target }
+                    : { kind: 'exact', version: target },
+                allowInterruptActiveTasks: false,
+                expectedSource: {
+                    rootId,
+                    deploymentRevision: record.revision,
+                    ownerInstallationId: installation.owner.installationId,
+                    hostEpoch,
+                },
+            });
+        }
+        return deps.withAuthority(rootId, async (authority, inheritableAuthorityLeaseFd) => {
+            if (!isDeepStrictEqual(await authority.read(), record)) {
+                throw new Error(copy.ownerChanged);
+            }
+            // Same-artifact restart is a process lifecycle operation, not an update.
+            // Open the already verified selected package; never restage/reinstall it.
+            const staged = input.action.action === 'restart'
+                ? await deps.openStaged({
+                    rootId,
+                    owner: installation.owner,
+                    target: record.state.selected,
+                    transactionId: `tui-restart:${randomUUID()}`,
+                })
+                : undefined;
+            if (await deps.resolveManagedAuthority(rootId))
+                throw new Error(copy.notOwner);
+            const retired = await deps.retire({
+                rootPath: input.rootPath,
+                rootId,
+                allowInterruptActiveTasks,
+                connectExisting: async (request) => {
+                    const current = await deps.connectExisting(request);
+                    if (current.kind !== 'connected' ||
+                        current.registration.rootId !== rootId ||
+                        current.registration.hostEpoch !== hostEpoch ||
+                        current.registration.lifecycleMode !== 'ephemeral') {
+                        if (current.kind === 'connected')
+                            await current.connection.close();
+                        throw new Error(copy.retirementHostChanged);
+                    }
+                    const currentDiagnostics = await current.connection
+                        .request('host.diagnostics.query', {})
+                        .catch(() => undefined);
+                    if (allowInterruptActiveTasks &&
+                        activityFingerprint(currentDiagnostics) !== fingerprint) {
+                        await current.connection.close();
+                        throw new Error(copy.activityChanged);
+                    }
+                    return current;
+                },
+            });
+            if (retired.kind === 'active_tasks') {
+                throw new Error(formatUiMessage(copy.stillActive, { action: input.action.action }, locale));
+            }
+            await retired.owner.close();
+            if (staged) {
+                const activated = await deps.activate({
+                    rootPath: input.rootPath,
+                    rootId,
+                    staged,
+                    ownerInstallationId: installation.owner.installationId,
+                    target: record.state.selected,
+                    inheritableAuthorityLeaseFd,
+                });
+                if (activated.kind !== 'ready')
+                    throw new Error(formatUiMessage(copy.restartFailed, { detail: activated.kind }, locale));
+                await activated.settle();
+            }
+            return 0;
+        });
+    };
+}
+function activityFingerprint(diagnostics) {
+    if (!diagnostics)
+        return 'unknown';
+    return JSON.stringify([
+        diagnostics.hostEpoch,
+        diagnostics.pid,
+        diagnostics.state,
+        diagnostics.connections,
+        diagnostics.activeOperations,
+        diagnostics.residencies,
+        diagnostics.upgradeBlockingActivity,
+    ]);
+}
+export async function describeTuiHost(input) {
+    const locale = input.locale ?? 'en';
+    const copy = getTuiHostOwnerCopy(locale);
+    const status = await input.connection.status();
+    return [
+        formatUiMessage(copy.status, { name: input.profile.name, state: copy[`state_${status.state}`] }, locale),
+        formatUiMessage(copy.root, { root: input.connection.rootId }, locale),
+        formatUiMessage(copy.epoch, { epoch: status.hostEpoch }, locale),
+        formatUiMessage(copy.composition, { composition: status.compositionId, revision: status.compositionRevision }, locale),
+        formatUiMessage(copy.activity, {
+            connections: status.connections,
+            operations: status.activeOperations,
+            residencies: status.activeResidencies,
+        }, locale),
+        input.profile.kind === 'local' ? copy.localOwnerHint : copy.attachedOwnerHint,
+    ].join('\n');
+}

package/dist/tui-copy-catalog.js

@@ -17,6 +17,137 @@
  * under the License.
  */
 export const TUI_COPY_RESOURCES = {
+    'host-owner': {
+        en: {
+            unavailable: 'Runtime Host owner controls are unavailable.',
+            usage: 'Usage: /host [status|stop|restart] or /update [latest|next|version]',
+            pickerTitle: 'Runtime Host owner action',
+            cancel: 'Cancel',
+            cancelDescription: 'Keep this Host and its work running',
+            safe: 'Safe handoff',
+            safeDescription: 'Continue only at a verified safe boundary',
+            interrupt: 'Interrupt active work',
+            interruptDescription: 'May stop work from every attached Surface',
+            pending: 'A Host owner action is already pending.',
+            disconnected: 'The TUI has already disconnected.',
+            foreign: 'This TUI is attached to another Host. Run its owner controls on that Host; /exit only disconnects.',
+            notOwner: 'This npm-global installation does not own the local Host. Use its actual operator; /exit only disconnects.',
+            hostChanged: 'The local Host changed or requires its managed-service operator.',
+            actionSummary: '{action}: {name}',
+            action_stop: 'Stop',
+            action_restart: 'Restart',
+            action_update: 'Update',
+            owner: 'Owner: {owner}',
+            root: 'Root: {root}',
+            epoch: 'Epoch: {epoch}',
+            composition: 'Composition: {composition} ({revision})',
+            activity: 'Connections: {connections}; operations: {operations}; residencies: {residencies}',
+            unknownActivity: 'Activity is unknown. Other Surfaces and autonomous tasks may be affected.',
+            updateSafeOnly: 'Update supports safe handoff only.',
+            invalidTarget: 'Update target must be latest, next, or an exact release version.',
+            updateRequiresSafe: 'TUI update uses safe handoff only. Stop active work explicitly before updating.',
+            installationChanged: 'The npm-global installation changed. Reopen Maka before retrying.',
+            ownerChanged: 'The local Host installation owner changed. Reopen Maka before retrying.',
+            retirementHostChanged: 'The Host changed before owner retirement; no replacement was interrupted.',
+            activityChanged: 'Host activity changed after confirmation. Reopen Maka and confirm the new work before retrying.',
+            stillActive: 'The Host still has active work. Reopen Maka and retry /host {action}; interruption requires a new confirmation.',
+            restartFailed: 'Host restart did not complete: {detail}',
+            status: '{name}: {state}',
+            state_starting: 'Starting',
+            state_containing: 'Containing',
+            state_recovering: 'Recovering',
+            state_ready: 'Ready',
+            state_draining: 'Draining',
+            localOwnerHint: 'Owner controls require this npm-global installation to own the Host. /exit only disconnects.',
+            attachedOwnerHint: 'Attached Host: lifecycle changes require its operator. /exit only disconnects.',
+        },
+        'zh-CN': {
+            unavailable: 'Runtime Host 所有者控制不可用。',
+            usage: '用法：/host [status|stop|restart] 或 /update [latest|next|version]',
+            pickerTitle: 'Runtime Host 所有者操作',
+            cancel: '取消',
+            cancelDescription: '保持此 Host 及其任务运行',
+            safe: '安全交接',
+            safeDescription: '仅在已验证的安全边界继续',
+            interrupt: '中断活动任务',
+            interruptDescription: '可能停止所有已连接界面的任务',
+            pending: '已有 Host 所有者操作等待执行。',
+            disconnected: 'TUI 已断开连接。',
+            foreign: '此 TUI 连接的是其他 Host。请在该 Host 上使用其所有者控制；/exit 仅断开连接。',
+            notOwner: '此 npm-global 安装不是本地 Host 的所有者。请使用实际所有者的控制工具；/exit 仅断开连接。',
+            hostChanged: '本地 Host 已变更，或需要由其托管服务控制工具操作。',
+            actionSummary: '{action}：{name}',
+            action_stop: '停止',
+            action_restart: '重启',
+            action_update: '更新',
+            owner: '所有者：{owner}',
+            root: '根标识：{root}',
+            epoch: '实例标识：{epoch}',
+            composition: '运行组成：{composition}（{revision}）',
+            activity: '连接数：{connections}；操作数：{operations}；常驻任务：{residencies}',
+            unknownActivity: '活动状态未知。其他界面和自主任务可能受到影响。',
+            updateSafeOnly: '更新仅支持安全交接。',
+            invalidTarget: '更新目标必须为 latest、next 或确切的发布版本。',
+            updateRequiresSafe: 'TUI 更新仅使用安全交接。更新前请先显式停止活动任务。',
+            installationChanged: 'npm-global 安装已变更。请重新打开 Maka 后重试。',
+            ownerChanged: '本地 Host 的安装所有者已变更。请重新打开 Maka 后重试。',
+            retirementHostChanged: '停止旧实例前 Host 已变更；未中断替代实例。',
+            activityChanged: '确认后 Host 活动已变更。请重新打开 Maka，确认新的任务后重试。',
+            stillActive: 'Host 仍有活动任务。请重新打开 Maka 并重试 /host {action}；中断需要重新确认。',
+            restartFailed: 'Host 重启未完成：{detail}',
+            status: '{name}：{state}',
+            state_starting: '启动中',
+            state_containing: '故障隔离中',
+            state_recovering: '恢复中',
+            state_ready: '就绪',
+            state_draining: '排空中',
+            localOwnerHint: '仅当此 npm-global 安装拥有该 Host 时才能使用所有者控制。/exit 仅断开连接。',
+            attachedOwnerHint: '已连接的 Host：生命周期变更需由其所有者操作。/exit 仅断开连接。',
+        },
+        'zh-TW': {
+            unavailable: 'Runtime Host 擁有者控制無法使用。',
+            usage: '用法：/host [status|stop|restart] 或 /update [latest|next|version]',
+            pickerTitle: 'Runtime Host 擁有者操作',
+            cancel: '取消',
+            cancelDescription: '保持此 Host 及其工作執行',
+            safe: '安全交接',
+            safeDescription: '僅在已驗證的安全邊界繼續',
+            interrupt: '中斷進行中的工作',
+            interruptDescription: '可能停止所有已連線介面的工作',
+            pending: '已有 Host 擁有者操作等待執行。',
+            disconnected: 'TUI 已中斷連線。',
+            foreign: '此 TUI 連線的是其他 Host。請在該 Host 上使用其擁有者控制；/exit 僅中斷連線。',
+            notOwner: '此 npm-global 安裝不是本機 Host 的擁有者。請使用實際擁有者的控制工具；/exit 僅中斷連線。',
+            hostChanged: '本機 Host 已變更，或需要由其託管服務控制工具操作。',
+            actionSummary: '{action}：{name}',
+            action_stop: '停止',
+            action_restart: '重新啟動',
+            action_update: '更新',
+            owner: '擁有者：{owner}',
+            root: '根識別碼：{root}',
+            epoch: '執行個體識別碼：{epoch}',
+            composition: '執行組成：{composition}（{revision}）',
+            activity: '連線數：{connections}；操作數：{operations}；常駐工作：{residencies}',
+            unknownActivity: '活動狀態未知。其他介面和自主工作可能受到影響。',
+            updateSafeOnly: '更新僅支援安全交接。',
+            invalidTarget: '更新目標必須為 latest、next 或確切的發行版本。',
+            updateRequiresSafe: 'TUI 更新僅使用安全交接。更新前請先明確停止進行中的工作。',
+            installationChanged: 'npm-global 安裝已變更。請重新開啟 Maka 後重試。',
+            ownerChanged: '本機 Host 的安裝擁有者已變更。請重新開啟 Maka 後重試。',
+            retirementHostChanged: '停止舊執行個體前 Host 已變更；未中斷替代執行個體。',
+            activityChanged: '確認後 Host 活動已變更。請重新開啟 Maka，確認新的工作後重試。',
+            stillActive: 'Host 仍有進行中的工作。請重新開啟 Maka 並重試 /host {action}；中斷需要重新確認。',
+            restartFailed: 'Host 重新啟動未完成：{detail}',
+            status: '{name}：{state}',
+            state_starting: '啟動中',
+            state_containing: '故障隔離中',
+            state_recovering: '復原中',
+            state_ready: '就緒',
+            state_draining: '排空中',
+            localOwnerHint: '僅當此 npm-global 安裝擁有該 Host 時才能使用擁有者控制。/exit 僅中斷連線。',
+            attachedOwnerHint: '已連線的 Host：生命週期變更需由其擁有者操作。/exit 僅中斷連線。',
+        },
+    },
     copy: {
         en: {
             copiedLast: 'Sent the last reply to the terminal via OSC 52 · {count, plural, one {# char} other {# chars}} — it reaches the clipboard only if your terminal (and tmux, if used) allows OSC 52 writes.',
@@ -711,7 +842,9 @@ export const TUI_COPY_RESOURCES = {
                 compact: 'Compact session context',
                 context: 'Show latest request context usage',
                 copy: 'Copy the last reply (or /copy all) to the clipboard',
-                exit: 'Exit Maka',
+                exit: 'Disconnect this TUI; leave the attached Host running',
+                host: 'Inspect the Host or stop/restart its local owner',
+                update: 'Update the npm-global CLI and its local Host',
                 goal: 'Show autonomous goal status',
                 graph: 'Show, enable, disable, or run one Graph turn',
                 help: 'Show commands and keybindings',
@@ -762,7 +895,9 @@ export const TUI_COPY_RESOURCES = {
                 compact: '压缩会话上下文',
                 context: '查看最近一次请求的上下文用量',
                 copy: '复制最后一条回复（或 /copy all）到剪贴板',
-                exit: '退出 Maka',
+                exit: '断开此 TUI，保留已连接的 Host',
+                host: '查看 Host 状态或停止、重启本地所有者',
+                update: '更新 npm 全局 CLI 及其本地 Host',
                 goal: '查看自主目标状态',
                 graph: '查看、启用、停用 Graph 模式，或执行一次 Graph 任务',
                 help: '查看命令和快捷键',
@@ -813,7 +948,9 @@ export const TUI_COPY_RESOURCES = {
                 compact: '壓縮會話上下文',
                 context: '檢視最近一次請求的上下文用量',
                 copy: '複製最後一則回覆（或 /copy all）到剪貼簿',
-                exit: '退出 Maka',
+                exit: '中斷此 TUI，保留已連線的 Host',
+                host: '查看 Host 狀態或停止、重新啟動本機擁有者',
+                update: '更新 npm 全域 CLI 及其本機 Host',
                 goal: '檢視自主目標狀態',
                 graph: '檢視、啟用、停用 Graph 模式，或執行一次 Graph 任務',
                 help: '檢視命令和快捷鍵',

package/dist/tui-host-owner-copy.js

@@ -0,0 +1,24 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { defineUiMessageCatalog, resolveUiMessageCatalog, } from '@maka/core/ui-locale';
+import { TUI_COPY_RESOURCES } from './tui-copy-catalog.js';
+const HOST_OWNER_COPY = resolveUiMessageCatalog(defineUiMessageCatalog()(TUI_COPY_RESOURCES['host-owner']));
+export function getTuiHostOwnerCopy(locale) {
+    return HOST_OWNER_COPY[locale];
+}

package/node_modules/@maka/core/dist/bot-events.js

@@ -22,6 +22,7 @@
  * different copy without diluting the core message. Exported so the
  * handler can use it AND a contract test can pin it.
  */
+// bot-channel notices follow the bot audience language; localization tracked under #2672
 export function nonTextMessageAck(kind) {
     switch (kind) {
         case 'photo':
@@ -139,74 +140,28 @@ function sanitizeBotUserName(value) {
         .trim() || 'unknown');
 }
 /**
- * PR-BOT-LASTERROR-FROM-SEND-0 (external bot research): translate the bridge's
- * machine-readable `BotStatus.reason` into a short user-readable string
- * suitable for persistence in `BotChannelSettings.lastError`. The Settings
- * page reads `lastError` from persisted settings (not live status), so
- * without this persistence step the user sees stale connection-test
- * errors instead of the actual send-path failure that happened minutes
- * ago.
- *
- * Returns `undefined` for non-error reasons (disabled/stopped/missing
- * credentials — those have their own UI surface) and for unrecognized
- * inputs whose pass-through risks leaking unredacted payloads.
- *
- * Length-capped at 200 chars defensively; a real Telegram error
- * description is typically well under 80 chars.
+ * Non-error `BotStatus.reason` values. These states have their own UI surface,
+ * so an error readout must not repeat them as failures.
  */
-const BOT_REASON_HUMANIZE = {
-    'rate-limited': '发送被节流（429）；上一条回复可能截断，可以请用户再发一次',
-    'polling-timeout': '事件轮询超时；可能是网络抖动或代理失效',
-    'send-failed': '上一次发送失败，详细原因 Telegram 没有返回',
-    'get-me-failed': '凭据探测失败；请检查 Bot Token',
-    // Non-error states surface elsewhere in the UI — return undefined so
-    // we do not overwrite a real lastError with a benign status change.
-    disabled: undefined,
-    stopped: undefined,
-    'no-token': undefined,
-    'missing-feishu-credentials': undefined,
-    'feishu-domain-required': undefined,
-    'feishu-events-not-connected': undefined,
-    'scaffold-only': undefined,
-    unimplemented: undefined,
-};
+const BOT_BENIGN_STATUS_REASONS = new Set([
+    'disabled',
+    'stopped',
+    'token_missing',
+    'feishu_credentials_missing',
+    'feishu-domain-required',
+    'feishu-events-not-connected',
+    'scaffold-only',
+    'unimplemented',
+]);
 /**
- * PR-BOT-RUNTIME-REASON-HUMANIZE-0: Discord / DingTalk / QQ bridges
- * emit parameterized reason strings like `gateway-closed-4004` and
- * `connections-open-500`. Without these patterns the user sees the
- * raw machine code in `lastError`; with them they get a translated
- * description plus the diagnostic code preserved in parentheses.
- *
- * Each entry is a regex with one numeric capture group; the matched
- * code is preserved verbatim so support diagnostics still survive.
+ * `BotStatus.reason` stays a stable code; presenters own the copy. Benign
+ * states yield `undefined` so they never overwrite a real error readout.
  */
-const BOT_REASON_HUMANIZE_PATTERNS = [
-    { pattern: /^gateway-bot-(\d+)$/, format: (code) => `获取 Gateway 失败（HTTP ${code}）` },
-    { pattern: /^gateway-closed-(\d+)$/, format: (code) => `Gateway 连接关闭（${code}）；正在重连` },
-    { pattern: /^connections-open-(\d+)$/, format: (code) => `Stream 订阅打开失败（HTTP ${code}）` },
-    { pattern: /^stream-closed-(\d+)$/, format: (code) => `Stream 连接关闭（${code}）；正在重连` },
-    { pattern: /^send-failed-(\d+)$/, format: (code) => `发送失败（HTTP ${code}）` },
-    {
-        pattern: /^getAppAccessToken-(\d+)$/,
-        format: (code) => `获取 access_token 失败（HTTP ${code}）`,
-    },
-];
-export function humanizeBotStatusReason(reason) {
-    if (typeof reason !== 'string' || reason.length === 0)
+export function botStatusErrorReason(reason) {
+    if (typeof reason !== 'string')
         return undefined;
-    if (reason in BOT_REASON_HUMANIZE) {
-        return BOT_REASON_HUMANIZE[reason];
-    }
-    for (const { pattern, format } of BOT_REASON_HUMANIZE_PATTERNS) {
-        const match = pattern.exec(reason);
-        if (match)
-            return format(match[1]);
-    }
-    // Pass-through for platform-supplied descriptions ("Bad Request:
-    // chat not found", etc.). Trim + length-cap to keep `lastError`
-    // bounded.
     const trimmed = reason.trim();
-    if (trimmed.length === 0)
+    if (trimmed.length === 0 || BOT_BENIGN_STATUS_REASONS.has(trimmed))
         return undefined;
     return trimmed.length > 200 ? trimmed.slice(0, 200) : trimmed;
 }

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

@@ -93,7 +93,9 @@ function omitUndefinedEnvelopeFields(value) {
         }
         if (descriptor.value === undefined)
             continue;
-        Object.defineProperty(result, key, descriptor);
+        // This is our normalization copy. Frozen snapshots constrain their owner,
+        // not this copy; retaining non-configurable flags prevents normalizing it.
+        Object.defineProperty(result, key, { ...descriptor, configurable: true, writable: true });
     }
     return result;
 }

package/node_modules/@maka/core/dist/model-call-attempt.js

@@ -349,15 +349,6 @@ export function decodeModelCallAttempt(value) {
     }
     return value;
 }
-export function isModelCallAttempt(value) {
-    try {
-        decodeModelCallAttempt(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 /**
  * Collapses re-appended records by `attemptId`, keeping the last occurrence.
  *
@@ -389,76 +380,3 @@ export function groupModelCallAttempts(attempts) {
     }
     return [...groups.values()];
 }
-/**
- * The attempt that settled a logical call: the highest `attempt` ordinal that
- * reached a provider outcome. Terminality is a projection concern, not a stored
- * field, so it is derived rather than recorded.
- */
-export function settledAttempt(group) {
-    let settled;
-    for (const attempt of group.attempts) {
-        if (!settled || attempt.attempt > settled.attempt)
-            settled = attempt;
-    }
-    return settled;
-}
-/**
- * Extracts the canonical attempts a run committed, from that run's AgentRun
- * events. This is the projection the Usage read model is rebuilt through, so it
- * has to be total: an event that cannot be decoded is counted, not thrown, or
- * one bad record would block every later one in the same run from ever being
- * projected.
- */
-export function modelCallAttemptsFromRunEvents(events) {
-    const attempts = [];
-    let unreadableEvents = 0;
-    for (const event of events) {
-        if (event.type !== MODEL_CALL_ATTEMPT_EVENT_TYPE)
-            continue;
-        try {
-            attempts.push(decodeModelCallAttempt(event.data));
-        }
-        catch {
-            unreadableEvents += 1;
-        }
-    }
-    return { attempts, unreadableEvents };
-}
-export function summarizeModelCallCoverage(attempts) {
-    const unique = dedupeModelCallAttempts(attempts);
-    const coverage = {
-        attempts: unique.length,
-        pricedAttempts: 0,
-        unpricedAttempts: 0,
-        usageReportedAttempts: 0,
-        usagePartialAttempts: 0,
-        usageMissingAttempts: 0,
-    };
-    for (const attempt of unique) {
-        if (attempt.costBasis === 'priced')
-            coverage.pricedAttempts += 1;
-        else
-            coverage.unpricedAttempts += 1;
-        if (attempt.usageBasis === 'reported')
-            coverage.usageReportedAttempts += 1;
-        else if (attempt.usageBasis === 'partial')
-            coverage.usagePartialAttempts += 1;
-        else
-            coverage.usageMissingAttempts += 1;
-    }
-    return coverage;
-}
-/**
- * Sums cost across attempts. Returns the total alongside the coverage that
- * qualifies it, because a bare number cannot express "plus an unknown amount
- * from unpriced calls".
- */
-export function sumModelCallCostUsd(attempts) {
-    const unique = dedupeModelCallAttempts(attempts);
-    let costUsd = 0;
-    for (const attempt of unique) {
-        if (attempt.costBasis === 'priced' && attempt.costUsd !== undefined)
-            costUsd += attempt.costUsd;
-    }
-    return { costUsd, coverage: summarizeModelCallCoverage(unique) };
-}