@sema-agent/client-core 0.82.7 → 0.83.1

package/dist/pluginHooksWire.js

@@ -0,0 +1,429 @@
+import { displayUntrusted } from './displayUntrusted.js';
+export const ENGINE_FIRED_HOOK_EVENTS = [
+    'PreToolUse',
+    'PostToolUse',
+    'PostToolUseFailure',
+    'PostToolBatch',
+    'PreCompact',
+    'PostCompact',
+    'Stop',
+    'StopFailure',
+    'UserPromptSubmit',
+];
+export const PLUGIN_HOOK_DISPOSITIONS = ['engine', 'shell', 'not_run'];
+export const PLUGIN_HOOK_REASONS = [
+    'projected',
+    'shell_event',
+    'no_executor',
+    'engine_not_local',
+    'engine_locality_unknown',
+    'engine_capability_absent',
+    'engine_capability_unknown',
+    'not_command',
+    'sensitive_options',
+    'engine_limit',
+    'shell_form_user_config',
+    'user_config_unset',
+    'malformed_entry',
+];
+export const PLUGIN_HOOK_EXCLUSION_REASONS = [
+    'workspace_untrusted',
+    'governance_unreadable',
+    'policy_disable_all',
+    'startup_mode',
+    'managed_plugins_only',
+];
+export const SETTINGS_HOOK_DROP_REASONS = ['exec_form_unsupported', 'mcp_tool_unsupported'];
+export const ENGINE_HOOK_LIMITS = { maxGroupsPerEvent: 16, maxEntriesPerEvent: 32, maxCommandChars: 8192 };
+const ENGINE_EVENTS = new Set(ENGINE_FIRED_HOOK_EVENTS);
+const USER_CONFIG_REF_ONE = /\$\{user_config\.[^}]+\}/;
+const USER_CONFIG_REF_ALL = /\$\{user_config\.([^}]+)\}/g;
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function nonEmptyString(v) {
+    return typeof v === 'string' && v.length > 0;
+}
+export function isEngineFiredHookEvent(event) {
+    return ENGINE_EVENTS.has(event);
+}
+function declaresSensitive(options) {
+    if (options === undefined)
+        return false;
+    if (!isRecord(options))
+        return true;
+    return Object.values(options).some((o) => !isRecord(o) || o.sensitive !== false);
+}
+function savedPlainValue(options, key) {
+    if (!isRecord(options) || !Object.hasOwn(options, key))
+        return undefined;
+    const o = options[key];
+    if (!isRecord(o) || o.sensitive !== false)
+        return undefined;
+    const v = o.value;
+    return v === undefined || v === null ? undefined : String(v);
+}
+function declaredSensitiveKey(options, key) {
+    if (!isRecord(options) || !Object.hasOwn(options, key))
+        return false;
+    const o = options[key];
+    return !isRecord(o) || o.sensitive !== false;
+}
+function optionEnvKey(key) {
+    return key.replace(/[^A-Za-z0-9_]/g, '_').toUpperCase();
+}
+function projectedOptions(options) {
+    if (!isRecord(options))
+        return undefined;
+    const out = {};
+    let any = false;
+    for (const key of Object.keys(options)) {
+        const v = savedPlainValue(options, key);
+        if (v === undefined)
+            continue;
+        out[optionEnvKey(key)] = v;
+        any = true;
+    }
+    return any ? out : undefined;
+}
+function substituteUserConfig(s, options) {
+    return s.replace(USER_CONFIG_REF_ALL, (whole, key) => savedPlainValue(options, key) ?? whole);
+}
+function classifyEntry(entry, options) {
+    if (!isRecord(entry) || typeof entry.type !== 'string')
+        return { kind: 'malformed' };
+    if (entry.type !== 'command')
+        return { kind: 'other' };
+    const command = entry.command;
+    if (!nonEmptyString(command))
+        return { kind: 'malformed' };
+    const args = entry.args;
+    if (args === undefined)
+        return { kind: 'shell_form', refusesUserConfig: USER_CONFIG_REF_ONE.test(command) };
+    if (!Array.isArray(args) || !args.every((a) => typeof a === 'string'))
+        return { kind: 'malformed' };
+    const unset = [command, ...args].some((s) => [...s.matchAll(USER_CONFIG_REF_ALL)].some((mm) => mm[1] !== undefined && !declaredSensitiveKey(options, mm[1]) && savedPlainValue(options, mm[1]) === undefined));
+    return { kind: 'exec_form', command, args, unsetUserConfig: unset };
+}
+export function occupancyOf(wire) {
+    const out = new Map();
+    for (const [event, groups] of Object.entries(wire)) {
+        if (!Array.isArray(groups))
+            continue;
+        let entries = 0;
+        for (const g of groups)
+            if (isRecord(g) && Array.isArray(g.hooks))
+                entries += g.hooks.length;
+        out.set(event, { groups: groups.length, entries });
+    }
+    return out;
+}
+export function decidePluginHooks(input) {
+    const verdicts = [];
+    const excluded = [];
+    const candidates = new Map();
+    let unreadable = 0;
+    const fallback = (event, reason) => input.shellHookEvents.has(event) ? { disposition: 'shell', reason } : { disposition: 'not_run', reason };
+    input.plugins.forEach((p, pluginIndex) => {
+        if (!isRecord(p) || !isRecord(p.hooks)) {
+            unreadable++;
+            return;
+        }
+        const src = p;
+        const sourceOk = nonEmptyString(p.id) && nonEmptyString(p.name) && nonEmptyString(p.root) && nonEmptyString(p.dataDir);
+        const pluginId = typeof p.id === 'string' ? p.id : '';
+        const pluginName = typeof p.name === 'string' ? p.name : '';
+        for (const [event, groups] of Object.entries(p.hooks)) {
+            if (!Array.isArray(groups)) {
+                unreadable++;
+                continue;
+            }
+            ;
+            groups.forEach((group, groupIndex) => {
+                if (!isRecord(group) || !Array.isArray(group.hooks)) {
+                    unreadable++;
+                    return;
+                }
+                ;
+                group.hooks.forEach((entry, hookIndex) => {
+                    const key = { pluginId, pluginName, event, groupIndex, hookIndex };
+                    if (input.exclusion !== undefined) {
+                        excluded.push({ ...key, reason: input.exclusion });
+                        return;
+                    }
+                    if (input.managedOnly && p.managed !== true) {
+                        excluded.push({ ...key, reason: 'managed_plugins_only' });
+                        return;
+                    }
+                    const shape = sourceOk ? classifyEntry(entry, src.options) : { kind: 'malformed' };
+                    if (shape.kind === 'malformed') {
+                        verdicts.push({ ...key, disposition: 'not_run', reason: 'malformed_entry' });
+                        return;
+                    }
+                    if (shape.kind === 'shell_form' && shape.refusesUserConfig) {
+                        verdicts.push({ ...key, disposition: 'not_run', reason: 'shell_form_user_config' });
+                        return;
+                    }
+                    if (shape.kind === 'exec_form' && shape.unsetUserConfig) {
+                        verdicts.push({ ...key, disposition: 'not_run', reason: 'user_config_unset' });
+                        return;
+                    }
+                    if (!ENGINE_EVENTS.has(event)) {
+                        verdicts.push({
+                            ...key,
+                            ...(input.shellHookEvents.has(event)
+                                ? { disposition: 'shell', reason: 'shell_event' }
+                                : { disposition: 'not_run', reason: 'no_executor' }),
+                        });
+                        return;
+                    }
+                    const blocked = input.engine.ownedByThisShell === null
+                        ? 'engine_locality_unknown'
+                        : !input.engine.ownedByThisShell
+                            ? 'engine_not_local'
+                            : input.engine.pluginHooksCapable === null
+                                ? 'engine_capability_unknown'
+                                : !input.engine.pluginHooksCapable
+                                    ? 'engine_capability_absent'
+                                    : shape.kind === 'other'
+                                        ? 'not_command'
+                                        : declaresSensitive(src.options)
+                                            ? 'sensitive_options'
+                                            : undefined;
+                    if (blocked !== undefined) {
+                        verdicts.push({ ...key, ...fallback(event, blocked) });
+                        return;
+                    }
+                    const plugin = { name: src.name, root: src.root, dataDir: src.dataDir };
+                    const options = projectedOptions(src.options);
+                    if (options !== undefined)
+                        plugin.options = options;
+                    const wireEntry = { ...entry, plugin };
+                    if (shape.kind === 'exec_form') {
+                        wireEntry.command = substituteUserConfig(shape.command, src.options);
+                        wireEntry.args = shape.args.map((a) => substituteUserConfig(a, src.options));
+                    }
+                    const verdict = { ...key, disposition: 'engine', reason: 'projected' };
+                    verdicts.push(verdict);
+                    const list = candidates.get(event) ?? [];
+                    list.push({ verdict, pluginIndex, group, wireEntry });
+                    candidates.set(event, list);
+                });
+            });
+        }
+    });
+    const projected = new Map();
+    for (const [event, list] of candidates) {
+        const fits = list.filter((c) => {
+            const cmd = c.wireEntry.command;
+            if (typeof cmd === 'string' && cmd.length <= ENGINE_HOOK_LIMITS.maxCommandChars)
+                return true;
+            Object.assign(c.verdict, fallback(event, 'engine_limit'));
+            return false;
+        });
+        if (fits.length === 0)
+            continue;
+        const groupKeys = [];
+        for (const c of fits) {
+            const k = `${c.pluginIndex}\u0000${c.verdict.groupIndex}`;
+            if (!groupKeys.includes(k))
+                groupKeys.push(k);
+        }
+        const occ = input.occupied.get(event) ?? { groups: 0, entries: 0 };
+        if (occ.groups + groupKeys.length > ENGINE_HOOK_LIMITS.maxGroupsPerEvent ||
+            occ.entries + fits.length > ENGINE_HOOK_LIMITS.maxEntriesPerEvent) {
+            for (const c of fits)
+                Object.assign(c.verdict, fallback(event, 'engine_limit'));
+            continue;
+        }
+        const groupsOut = [];
+        for (const k of groupKeys) {
+            const members = fits.filter((c) => `${c.pluginIndex}\u0000${c.verdict.groupIndex}` === k);
+            const first = members[0];
+            if (first === undefined)
+                continue;
+            groupsOut.push({ ...first.group, hooks: members.map((c) => c.wireEntry) });
+        }
+        projected.set(event, groupsOut);
+    }
+    return { verdicts, excluded, projected, unreadable };
+}
+const SHELL_INERT_COMMAND = /^[A-Za-z0-9_./:+-]+$/;
+function carriesArgs(entry) {
+    const args = entry.args;
+    if (args === undefined || args === null)
+        return false;
+    if (Array.isArray(args) && args.length === 0) {
+        const command = entry.command;
+        return !(typeof command === 'string' && SHELL_INERT_COMMAND.test(command));
+    }
+    return true;
+}
+export function filterSettingsHookGroups(source, event, groups, execFormCapable, hostFires, failLoudMcpTool) {
+    const drops = [];
+    const out = [];
+    let stripped = 0;
+    const engineEvent = ENGINE_EVENTS.has(event);
+    const notRun = engineEvent && !hostFires;
+    const keepMcpTool = failLoudMcpTool && engineEvent;
+    groups.forEach((group, groupIndex) => {
+        if (!isRecord(group) || !Array.isArray(group.hooks)) {
+            out.push(group);
+            return;
+        }
+        const kept = [];
+        let changed = false;
+        group.hooks.forEach((entry, hookIndex) => {
+            const reason = !isRecord(entry)
+                ? undefined
+                : entry.type === 'mcp_tool'
+                    ? keepMcpTool
+                        ? undefined
+                        : 'mcp_tool_unsupported'
+                    : entry.type === 'command' && carriesArgs(entry) && !execFormCapable
+                        ? 'exec_form_unsupported'
+                        : undefined;
+            if (reason !== undefined) {
+                drops.push({ source, event, groupIndex, hookIndex, reason, notRun });
+                changed = true;
+                return;
+            }
+            if (isRecord(entry) && Object.hasOwn(entry, 'plugin')) {
+                const copy = { ...entry };
+                delete copy.plugin;
+                kept.push(copy);
+                stripped++;
+                changed = true;
+                return;
+            }
+            kept.push(entry);
+        });
+        if (!changed)
+            out.push(group);
+        else if (kept.length > 0)
+            out.push({ ...group, hooks: kept });
+    });
+    return { groups: out, drops, stripped };
+}
+export function pluginHookVerdictOf(plan, pluginId, event, groupIndex, hookIndex) {
+    return plan.verdicts.find((v) => v.pluginId === pluginId && v.event === event && v.groupIndex === groupIndex && v.hookIndex === hookIndex);
+}
+const REASON_TEXT = {
+    projected: 'it is sent to the engine',
+    shell_event: 'this client runs this event itself',
+    no_executor: 'neither the engine nor this client runs this event',
+    engine_not_local: 'the engine was not started by this client on this machine, so it cannot reach the plugin files',
+    engine_locality_unknown: 'it is not known whether the engine was started by this client on this machine, so plugin hooks are not sent to it',
+    engine_capability_absent: 'the connected engine does not support plugin hooks',
+    engine_capability_unknown: 'it is not known yet whether the connected engine supports plugin hooks, so they are not sent to it',
+    not_command: 'only command hooks from plugins can run in the engine',
+    sensitive_options: 'the plugin has sensitive options, and those are never sent to the engine',
+    engine_limit: "sending it would exceed the engine's hook limits for this event",
+    shell_form_user_config: 'its command uses ${user_config.…} in shell form, which is refused (use exec form with "args", or read $CLAUDE_PLUGIN_OPTION_<KEY>)',
+    user_config_unset: 'its command uses a plugin option that has not been set',
+    malformed_entry: 'the hook entry is malformed',
+};
+const DROP_TEXT = {
+    exec_form_unsupported: 'exec-form hooks (with "args") are sent to the engine only once it reports support for them',
+    mcp_tool_unsupported: 'MCP tool hooks are not supported by the engine',
+};
+const SOURCE_TEXT = {
+    policySettings: 'Managed settings',
+    userSettings: 'User settings',
+    projectSettings: 'Project settings',
+    localSettings: 'Local settings',
+};
+export function pluginHookReasonText(reason) {
+    return REASON_TEXT[reason];
+}
+export function settingsHookDropText(reason) {
+    return DROP_TEXT[reason];
+}
+export function pluginHookExecutorLabel(v) {
+    switch (v.disposition) {
+        case 'engine':
+            return 'runs in the engine';
+        case 'shell':
+            return 'runs in this client';
+        case 'not_run':
+            return `does not run: ${pluginHookReasonText(v.reason)}`;
+    }
+}
+const NOTICE_LABEL_MAX = 120;
+const noticeLabel = (s) => capNoticeLabel(escapeNoticeQuotes(displayUntrusted(s, { credentialUrls: false, credentialWords: false })));
+function escapeNoticeQuotes(s) {
+    const budget = NOTICE_LABEL_MAX + 16;
+    const out = [];
+    let len = 0;
+    let i = 0;
+    while (i < s.length && len <= budget) {
+        const c = s.charCodeAt(i);
+        if (c === 0x5c) {
+            let j = i;
+            while (j < s.length && s.charCodeAt(j) === 0x5c)
+                j++;
+            const want = s.charCodeAt(j) === 0x22 ? (j - i) * 2 : j - i;
+            const take = Math.min(want, budget + 1 - len);
+            out.push('\\'.repeat(take));
+            len += take;
+            i = j;
+            continue;
+        }
+        if (c === 0x22) {
+            out.push('\\"');
+            len += 2;
+        }
+        else {
+            out.push(s.charAt(i));
+            len++;
+        }
+        i++;
+    }
+    return out.join('');
+}
+function capNoticeLabel(s) {
+    if (s.length <= NOTICE_LABEL_MAX)
+        return s;
+    const token = /\\u\{[0-9A-F]{1,6}\}|\\u[0-9A-F]{4}|\\[\\"]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[^]/gy;
+    let end = 0;
+    for (let t = token.exec(s); t !== null; t = token.exec(s)) {
+        if (t.index + t[0].length > NOTICE_LABEL_MAX - 1)
+            break;
+        end = t.index + t[0].length;
+    }
+    return `${s.slice(0, end)}…`;
+}
+export function hooksNotRunNotice(plan) {
+    const lines = [];
+    const byPlugin = new Map();
+    for (const v of plan.verdicts) {
+        if (v.disposition !== 'not_run')
+            continue;
+        const k = `${v.pluginId}\u0000${v.reason}`;
+        const row = byPlugin.get(k) ?? { name: v.pluginName, reason: v.reason, events: [], count: 0 };
+        if (!row.events.includes(v.event))
+            row.events.push(v.event);
+        row.count++;
+        byPlugin.set(k, row);
+    }
+    for (const row of byPlugin.values()) {
+        const events = row.events.map((e) => noticeLabel(e)).join(', ');
+        lines.push(`Plugin "${noticeLabel(row.name) || '(unnamed)'}": ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${pluginHookReasonText(row.reason)}.`);
+    }
+    const bySource = new Map();
+    for (const d of plan.settingsDropped) {
+        if (!d.notRun)
+            continue;
+        const k = `${d.source}\u0000${d.reason}`;
+        const row = bySource.get(k) ?? { source: d.source, reason: d.reason, events: [], count: 0 };
+        if (!row.events.includes(d.event))
+            row.events.push(d.event);
+        row.count++;
+        bySource.set(k, row);
+    }
+    for (const row of bySource.values()) {
+        const events = row.events.map((e) => noticeLabel(e)).join(', ');
+        lines.push(`${SOURCE_TEXT[row.source]}: ${events} ${row.count === 1 ? 'hook' : 'hooks'} will not run — ${settingsHookDropText(row.reason)}.`);
+    }
+    return lines;
+}

package/dist/printInitToolFace.js

@@ -19,7 +19,7 @@ export function printInitRosterSignal(message) {
         if (type === 'result')
             return { kind: 'no-roster', reason: 'run-ended' };
         if (type === 'assistant') {
-            return rec.isApiErrorMessage === true ? { kind: 'no-roster', reason: 'run-ended' } : { kind: 'no-roster', reason: 'model-activity-first' };
+            return rec._sema_api_error_message === true ? { kind: 'no-roster', reason: 'run-ended' } : { kind: 'no-roster', reason: 'model-activity-first' };
         }
         if (type === 'stream_event' || type === 'retry_status')
             return { kind: 'no-roster', reason: 'model-activity-first' };

package/dist/request/printNotification.js

@@ -10,19 +10,19 @@ export const PRINT_NOTIFICATION_FIELD_MATRIX = [
     { field: 'tool_use_id', from: 'toolUseId', cc: true, why: 'CC 逐字 snake 名(wire 是 camel);把通知钉回发起它的那次工具调用' },
     { field: 'output_file', from: 'output_file', cc: true, why: 'CC 逐字;后台输出落盘路径' },
     { field: 'usage', from: 'usage', cc: true, why: 'CC 逐字 optional;计量面(交互面 XML 反而不读它 —— 那是渲染面口径)' },
-    { field: 'stoppedBy', from: 'stoppedBy', cc: false, why: '🔴 残局归因核心位:谁停的(用户/上限/引擎)。修前 `-p` 出口零携带' },
-    { field: 'resumable', from: 'resumable', cc: false, why: '🔴 残局归因:还能不能 resume —— 自动化要靠它决定重试还是放弃' },
-    { field: 'partial', from: 'partial', cc: false, why: 'server 1.258:被终止子代的残果(消费方须渲成不完整,不得当完整结果)' },
-    { field: 'exitCode', from: 'exitCode', cc: false, why: '后台 bash 退出码(137=OOM 这类归因只在这一位上)' },
-    { field: 'diagnostics', from: 'diagnostics', cc: false, why: '引擎侧诊断串(UNTRUSTED,service 已 redact)' },
-    { field: 'result', from: 'result', cc: false, why: '完成结果正文(#49 C1:帧带 result 必入 XML,print 出口同理不得独漏)' },
-    { field: 'lines', from: 'lines', cc: false, why: '尾部输出行(UNTRUSTED);交互面折进 <output-lines>' },
-    { field: 'recentSteps', from: 'recentSteps', cc: false, why: '结构化残局步骤 {tool,target,outcome}[] —— **原样透传**,不降级成交互面那份显示串(SDK 消费方要结构)' },
-    { field: 'editedFiles', from: 'editedFiles', cc: false, why: '结构化改档清单 {path,edits}[];同上原样透传' },
-    { field: 'task_type', from: 'task_type', cc: false, why: 'lane 位(external/background_agent/…)—— 去重键的分域依据,消费方要能自己算同一把键' },
-    { field: 'source', from: 'source', cc: false, why: 'external lane 的来源标识(交互面渲成开标签 from= 属性)' },
-    { field: 'seq', from: 'seq', cc: false, why: '停机周期/批次计数([508]②)—— 与 task_id+status 一起构成去重键' },
-    { field: 'injected', from: 'injected', cc: false, why: '[1818]§四:本帧**不**证明 XML 已进模型上下文;消费方须按此位判,不得按帧到达判' },
+    { field: '_sema_stopped_by', from: 'stoppedBy', cc: false, why: '🔴 残局归因核心位:谁停的(用户/上限/引擎)。修前 `-p` 出口零携带' },
+    { field: '_sema_resumable', from: 'resumable', cc: false, why: '🔴 残局归因:还能不能 resume —— 自动化要靠它决定重试还是放弃' },
+    { field: '_sema_partial', from: 'partial', cc: false, why: 'server 1.258:被终止子代的残果(消费方须渲成不完整,不得当完整结果)' },
+    { field: '_sema_exit_code', from: 'exitCode', cc: false, why: '后台 bash 退出码(137=OOM 这类归因只在这一位上)' },
+    { field: '_sema_diagnostics', from: 'diagnostics', cc: false, why: '引擎侧诊断串(UNTRUSTED,service 已 redact)' },
+    { field: '_sema_result', from: 'result', cc: false, why: '完成结果正文(#49 C1:帧带 result 必入 XML,print 出口同理不得独漏)' },
+    { field: '_sema_lines', from: 'lines', cc: false, why: '尾部输出行(UNTRUSTED);交互面折进 <output-lines>' },
+    { field: '_sema_recent_steps', from: 'recentSteps', cc: false, why: '结构化残局步骤 {tool,target,outcome}[] —— **原样透传**,不降级成交互面那份显示串(SDK 消费方要结构)' },
+    { field: '_sema_edited_files', from: 'editedFiles', cc: false, why: '结构化改档清单 {path,edits}[];同上原样透传' },
+    { field: '_sema_task_type', from: 'task_type', cc: false, why: 'lane 位(external/background_agent/…)—— 去重键的分域依据,消费方要能自己算同一把键;CC 的 task_type 只在 task_started / task_progress 子型上且词表不同,故不占 CC 名' },
+    { field: '_sema_source', from: 'source', cc: false, why: 'external lane 的来源标识(交互面渲成开标签 from= 属性)' },
+    { field: '_sema_seq', from: 'seq', cc: false, why: '停机周期/批次计数([508]②)—— 与 task_id+status 一起构成去重键' },
+    { field: '_sema_injected', from: 'injected', cc: false, why: '[1818]§四:本帧**不**证明 XML 已进模型上下文;消费方须按此位判,不得按帧到达判' },
 ];
 const PRINT_FRAME_KEYS = new Set(PRINT_NOTIFICATION_FIELD_MATRIX.map(r => r.field));
 export function taskNotificationToPrintFrame(n, identity = {}) {
@@ -39,19 +39,19 @@ export function taskNotificationToPrintFrame(n, identity = {}) {
         ...(f.toolUseId !== undefined ? { tool_use_id: f.toolUseId } : {}),
         ...(f.outputFile !== undefined ? { output_file: f.outputFile } : {}),
         ...(n.usage !== undefined ? { usage: n.usage } : {}),
-        ...(f.stoppedBy !== undefined ? { stoppedBy: f.stoppedBy } : {}),
-        ...(f.resumable !== undefined ? { resumable: f.resumable } : {}),
-        ...(f.partial !== undefined ? { partial: f.partial } : {}),
-        ...(f.exitCode !== undefined ? { exitCode: f.exitCode } : {}),
-        ...(f.diagnostics !== undefined ? { diagnostics: f.diagnostics } : {}),
-        ...(f.result !== undefined ? { result: f.result } : {}),
-        ...(f.lines !== undefined ? { lines: f.lines } : {}),
-        ...(nonEmptyList(n.recentSteps) ? { recentSteps: n.recentSteps } : {}),
-        ...(nonEmptyList(n.editedFiles) ? { editedFiles: n.editedFiles } : {}),
-        ...(f.taskType !== undefined ? { task_type: f.taskType } : {}),
-        ...(f.externalSource !== undefined ? { source: f.externalSource } : {}),
-        ...(typeof n.seq === 'number' || typeof n.seq === 'string' ? { seq: n.seq } : {}),
-        ...(typeof n.injected === 'boolean' ? { injected: n.injected } : {}),
+        ...(f.stoppedBy !== undefined ? { _sema_stopped_by: f.stoppedBy } : {}),
+        ...(f.resumable !== undefined ? { _sema_resumable: f.resumable } : {}),
+        ...(f.partial !== undefined ? { _sema_partial: f.partial } : {}),
+        ...(f.exitCode !== undefined ? { _sema_exit_code: f.exitCode } : {}),
+        ...(f.diagnostics !== undefined ? { _sema_diagnostics: f.diagnostics } : {}),
+        ...(f.result !== undefined ? { _sema_result: f.result } : {}),
+        ...(f.lines !== undefined ? { _sema_lines: f.lines } : {}),
+        ...(nonEmptyList(n.recentSteps) ? { _sema_recent_steps: n.recentSteps } : {}),
+        ...(nonEmptyList(n.editedFiles) ? { _sema_edited_files: n.editedFiles } : {}),
+        ...(f.taskType !== undefined ? { _sema_task_type: f.taskType } : {}),
+        ...(f.externalSource !== undefined ? { _sema_source: f.externalSource } : {}),
+        ...(typeof n.seq === 'number' || typeof n.seq === 'string' ? { _sema_seq: n.seq } : {}),
+        ...(typeof n.injected === 'boolean' ? { _sema_injected: n.injected } : {}),
         ...(identity.uuid !== undefined ? { uuid: identity.uuid } : {}),
         ...(identity.session_id !== undefined ? { session_id: identity.session_id } : {}),
     };

package/dist/seam.d.ts

@@ -149,7 +149,7 @@ export type ChromeEvent = {
 } | ({
     kind: 'run_cost_reconciled';
     laneProof: LaneProof;
-} & RunCostReconcile) | HumanInputChromeEvent | MessageCommittedChromeEvent | EngineNoticeChromeEvent | TextSegmentEndChromeEvent | ThinkingSegmentEndChromeEvent | ToolDisclosureChromeEvent | ToolProgressChromeEvent | ToolRosterDeltaChromeEvent | ContextUsageChromeEvent | CompactionOutcomeChromeEvent | PromptAssembledChromeEvent | WiringManifestChromeEvent | ResultTextDivergedChromeEvent | ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent;
+} & RunCostReconcile) | HumanInputChromeEvent | MessageCommittedChromeEvent | EngineNoticeChromeEvent | TextSegmentEndChromeEvent | ThinkingSegmentEndChromeEvent | ToolDisclosureChromeEvent | ToolProgressChromeEvent | ToolRosterDeltaChromeEvent | ContextUsageChromeEvent | CompactionOutcomeChromeEvent | PromptAssembledChromeEvent | MemorySavedChromeEvent | WiringManifestChromeEvent | ResultTextDivergedChromeEvent | ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent;
 export interface WiringManifestChromeEvent {
     kind: 'wiring_manifest';
     laneProof: LaneProof;
@@ -204,6 +204,12 @@ export interface CompactionOutcomeChromeEvent {
     reason?: string;
     eventId?: string;
 }
+export interface MemorySavedChromeEvent {
+    kind: 'memory_saved';
+    laneProof: LaneProof;
+    id: string;
+    notes: string[];
+}
 export interface PromptAssembledChromeEvent {
     kind: 'prompt_assembled';
     laneProof: LaneProof;
@@ -330,4 +336,4 @@ export declare function deriveTranscriptId(frame: {
     id?: unknown;
     seq?: unknown;
     toolCallId?: unknown;
-}, ctx: Pick<AdapterContext, 'uuid'>): string;
+}, ctx: Pick<AdapterContext, 'uuid'>, suffix?: string): string;

package/dist/seam.js

@@ -1,3 +1,4 @@
+import { TRANSCRIPT_ID_NAMESPACE, uuidV5 } from './uuidV5.js';
 const CHROME_ARM_TABLE = {
     retry_status: { required: false, duty: '渲/清 spinner 的重试覆盖层' },
     panel_task: { required: true, duty: 'publishEngineAgentPanelEvent(event) 原样转发' },
@@ -63,6 +64,13 @@ const CHROME_ARM_TABLE = {
         duty: 'CC-08(0.71.0):每个压缩边界一条,按**最后一条**取当前值;`usedTokens > compactAtTokens` 是引擎的 shouldCompact 谓词,别重算;`windowTokens` 是 autocompact 窗,' +
             '别渲成模型上下文大小;🔴 `sections[].tokens` 与 `usedTokens` 不同坐标系,**禁相减**、禁拿一段比 `compactAtTokens`;`sections` 整键缺席 = 没装配出段 IR,不是各段为零。',
     },
+    memory_saved: {
+        required: true,
+        duty: '0.83.0 起记忆写入不再是转录行,只发本臂。`notes` 是记忆**笔记原文、不是路径**(别拼链接 / 判文件存在);' +
+            '要保留「Saved N memories」那一行的宿主把本臂还原成一条转录行:行 uuid 用 `id`(由这次写入的 wire 稳定键派生、重投同值,按它幂等;与 0.82.x 旧行 uuid 不相等),N = `notes.length`,时间戳在接收口取;' +
+            '落成 CC 形行时不许再造 `writtenPaths` / `isMeta` 这类 CC 在该臂上不声明的键;每次写入一条事件、本包不合并;' +
+            '没收到本臂不等于没写记忆(回执不成形时不发,工具卡照常在);laneProof 为 subagent = 子代写的,别渲成主会话的。',
+    },
     compaction_outcome: {
         required: false,
         duty: 'CC-89(0.75.0):一次压缩的非 compacted 结局(作废 / 失败等),给用户一条可见提示。`outcome` / `trigger` 是引擎开集原词,按成员渲染必带 default 臂、认不得照原词显示;' +
@@ -139,12 +147,15 @@ const CHROME_ARM_TABLE = {
     },
 };
 export const CHROME_ARMS = Object.entries(CHROME_ARM_TABLE).map(([kind, d]) => ({ kind, required: d.required, duty: d.duty }));
-export function deriveTranscriptId(frame, ctx) {
-    if (typeof frame.id === 'string' && frame.id.length > 0)
-        return `wid_${frame.id}`;
-    if (typeof frame.seq === 'number')
-        return `wseq_${frame.seq}`;
-    if (typeof frame.toolCallId === 'string' && frame.toolCallId.length > 0)
-        return `wtc_${frame.toolCallId}`;
+export function deriveTranscriptId(frame, ctx, suffix) {
+    if (typeof frame.id === 'string' && frame.id.length > 0) {
+        return uuidV5(TRANSCRIPT_ID_NAMESPACE, suffix !== undefined ? `wid_${frame.id}#${suffix}` : `wid_${frame.id}`);
+    }
+    if (typeof frame.seq === 'number') {
+        return uuidV5(TRANSCRIPT_ID_NAMESPACE, suffix !== undefined ? `wseq#${suffix}_${frame.seq}` : `wseq_${frame.seq}`);
+    }
+    if (typeof frame.toolCallId === 'string' && frame.toolCallId.length > 0) {
+        return uuidV5(TRANSCRIPT_ID_NAMESPACE, suffix !== undefined ? `wtc#${suffix}_${frame.toolCallId}` : `wtc_${frame.toolCallId}`);
+    }
     return ctx.uuid();
 }

package/dist/subagent/engineSubagentResume.js

@@ -1,5 +1,6 @@
 import { hostLog } from '../host.js';
 import { resumeRetryLaterFromError } from '../wireErrorTriage.js';
+import { displayUntrusted } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
 import { engineWireTargetFor } from '../engineWireTarget.js';
@@ -99,7 +100,7 @@ export function resolveSubagentResumeContext(childTaskId) {
     return { facade: client.runs, runId: resolveOwnerRunId(childTaskId), session };
 }
 function clean(v, max = 200) {
-    return String(v ?? '').replace(/[\x00-\x1f\x7f]/g, '.').slice(0, max);
+    return displayUntrusted(String(v ?? ''), { credentialUrls: false, credentialWords: false, foldLines: false, mark: 'dot', max });
 }
 export async function resumeSettledSubagent(facade, runId, target, content, opts) {
     if (facade === null)

package/dist/systemReminderTag.d.ts

@@ -1,3 +1,2 @@
 export declare function unwrapSystemReminder(text: string): string;
 export declare function stripSystemReminderBlocks(text: string): string;
-export declare function startsWithSystemReminderOpenTag(text: string): boolean;

package/dist/systemReminderTag.js

@@ -7,6 +7,3 @@ export function unwrapSystemReminder(text) {
 export function stripSystemReminderBlocks(text) {
     return text.replace(new RegExp(`${OPEN_TAG_SOURCE}[\\s\\S]*?<\\/system-reminder>`, 'g'), '');
 }
-export function startsWithSystemReminderOpenTag(text) {
-    return new RegExp(`^\\s*${OPEN_TAG_SOURCE}`).test(text);
-}

package/dist/toolResult.js

@@ -47,6 +47,7 @@ export const STRUCTURED_DETAIL_TYPES = new Set([
     'read_path_denied',
     'list-agents',
     'artifact',
+    'read-inbox',
 ]);
 export function structuredDetailType(structured) {
     if (typeof structured !== 'object' || structured === null)

package/dist/uuidV5.d.ts

@@ -0,0 +1,3 @@
+export declare const TRANSCRIPT_ID_NAMESPACE = "5935225a-0f39-4c72-b409-4893196112ab";
+export declare function utf8Encode(s: string): Uint8Array;
+export declare function uuidV5(namespace: string, name: string): string;