@sema-agent/client-core 0.83.4 → 0.83.6

package/dist/hitl/sessionPolicyDeliverable.d.ts

@@ -1,9 +1,10 @@
 import type { SessionPermissionRules } from '@sema-agent/sdk';
-export type SessionPolicyWithheldWhy = 'ask_no_bucket' | 'qualified_deny' | 'peer_wide' | 'wildcard' | 'not_a_tool_name';
+export type SessionPolicyWithheldWhy = 'ask_no_bucket' | 'qualified_deny' | 'peer_wide' | 'wildcard' | 'not_a_tool_name' | 'legacy_tool_name';
 export declare const SESSION_POLICY_WITHHELD_WHY: readonly SessionPolicyWithheldWhy[];
 export interface SessionPolicyWithheldRule {
     readonly rule: string;
     readonly why: SessionPolicyWithheldWhy;
+    readonly currentName?: string;
 }
 export interface SessionPolicyDeliverability {
     readonly deliverable: SessionPermissionRules;

package/dist/hitl/sessionPolicyDeliverable.js

@@ -1,16 +1,60 @@
+const COVERING_NAMESPACE_PREFIXES = ['mcp__', 'a2a__'];
+const ENGINE_RETIRED_TOOL_NAMES = new Map([
+    ['read_file', 'Read'],
+    ['edit_file', 'Edit'],
+    ['write_file', 'Write'],
+    ['bash', 'Bash'],
+    ['bash_readonly', null],
+    ['glob', 'Glob'],
+    ['grep', 'Grep'],
+    ['web_fetch', 'WebFetch'],
+    ['tool_search', 'ToolSearch'],
+    ['skill', 'Skill'],
+    ['present_plan', 'ExitPlanMode'],
+    ['enter_plan_mode', 'EnterPlanMode'],
+    ['spawn_subagent', 'Agent'],
+    ['CronCancel', 'CronDelete'],
+    ['lsp', 'LSP'],
+    ['submit_output', 'StructuredOutput'],
+    ['repo_map', 'RepoMap'],
+    ['read_tool_result', 'ReadToolResult'],
+    ['report_blocked', 'ReportBlocked'],
+    ['declare_done', 'DeclareDone'],
+    ['run_workflow', 'Workflow'],
+    ['RunWorkflow', 'Workflow'],
+    ['Task', 'Agent'],
+    ['BashOutput', 'TaskOutput'],
+    ['AgentOutputTool', 'TaskOutput'],
+    ['BashOutputTool', 'TaskOutput'],
+    ['AgentOutput', 'TaskOutput'],
+    ['WorkflowStatus', null],
+    ['KillShell', 'TaskStop'],
+    ['KillBash', 'TaskStop'],
+    ['ListMcpResources', 'ListMcpResourcesTool'],
+    ['ReadMcpResource', 'ReadMcpResourceTool'],
+    ['ReadMcpResourceDir', 'ReadMcpResourceDirTool'],
+    ['MultiEdit', null],
+    ['Fork', null],
+    ['Sleep', null],
+    ['Remember', null],
+    ['remember', null],
+    ['Recall', null],
+    ['recall', null],
+]);
+const PREFIXES_IN_PROSE = COVERING_NAMESPACE_PREFIXES.map((prefix) => `"${prefix}"`).join(' or ');
 const WITHHELD_NOTICE = {
     ask_no_bucket: 'Not written to this session’s rule record: that record only holds rules that block outright, and this rule asks before running instead — recording it as a block would change what it means.',
     qualified_deny: 'Not written to this session’s rule record: that record holds whole tool names and command names only, and this rule has a part in parentheses it cannot carry — recording just the name could block more than this rule does.',
-    peer_wide: 'Not written to this session’s rule record: this rule covers every tool of one server or agent peer, and an engine that matches that record by exact tool name would block none of them.',
+    peer_wide: 'Not written to this session’s rule record: this rule names a server or agent peer without naming one of its tools, and an engine that matches that record by exact tool name would block none of that peer’s tools.',
     wildcard: 'Not written to this session’s rule record: this rule uses a wildcard (*), and an engine that matches that record by exact tool name would block none of the tools it covers.',
     not_a_tool_name: 'Not written to this session’s rule record: this entry is not exactly one tool name — it is empty, not text, or has spaces around the name.',
+    legacy_tool_name: `Not written to this session’s rule record: unless a tool by exactly this name is available, the engine refuses it — it is a retired tool name, or it contains "__" but does not start with ${PREFIXES_IN_PROSE} — and with it in that record every later run of this session would fail at startup until that entry is removed from the record. If the tool still exists, use its current name; a server or agent-peer tool name starts with ${PREFIXES_IN_PROSE}.`,
 };
 export const SESSION_POLICY_WITHHELD_WHY = Object.freeze(Object.keys(WITHHELD_NOTICE));
 const MAX_RULES = 10_000;
 function unreadable() {
     return { deliverable: {}, withheld: [], unreadable: true };
 }
-const COVERING_NAMESPACE_PREFIXES = ['mcp__', 'a2a__'];
 function withheldWhyOf(rule) {
     if (rule.length === 0)
         return 'not_a_tool_name';
@@ -27,6 +71,10 @@ function withheldWhyOf(rule) {
     }
     if (rule.trim() !== rule)
         return 'not_a_tool_name';
+    if (ENGINE_RETIRED_TOOL_NAMES.has(rule))
+        return 'legacy_tool_name';
+    if (rule.includes('__') && !COVERING_NAMESPACE_PREFIXES.some((prefix) => rule.startsWith(prefix)))
+        return 'legacy_tool_name';
     return undefined;
 }
 export function sessionPolicyDeliverable(behavior, rules) {
@@ -66,8 +114,10 @@ export function sessionPolicyDeliverable(behavior, rules) {
         const why = withheldWhyOf(r);
         if (why === undefined)
             exact.push(r);
-        else
-            withheld.push({ rule: r, why });
+        else {
+            const currentName = why === 'legacy_tool_name' ? ENGINE_RETIRED_TOOL_NAMES.get(r) : undefined;
+            withheld.push(typeof currentName === 'string' ? { rule: r, why, currentName } : { rule: r, why });
+        }
     }
     if (withheld.length > 0 || exact.length === 0)
         return { deliverable: {}, withheld };

package/dist/hooksWireCaps.js

@@ -2,7 +2,7 @@ import { engineCapNestedTrue, engineCapState } from './engineCapsCache.js';
 import { displayUntrusted } from './displayUntrusted.js';
 import { collapseLabel } from './fleetTaskDesc.js';
 import { hostLog, hostSettings } from './host.js';
-import { decidePluginHooks, filterSettingsHookGroups, occupancyOf, settingsHookDropText, } from './pluginHooksWire.js';
+import { decidePluginHooks, dedupeSettingsHookGroups, filterSettingsHookGroups, occupancyOf, settingsHookDropText, } from './pluginHooksWire.js';
 import { MAX_HOOK_NOTICE_TEXT_CHARS } from './notifications.js';
 import { goalStopHookMatcher, __resetGoalStopHookForTests } from './goalStopHook.js';
 export { GOAL_STOP_HOOK_WIRE_ENV, CC_STOP_SEMANTICS_MIN_SERVER, ccStopSemanticsFromVersion, engineCcStopSemantics, isGoalStopHookWireArmed, setWireSessionStopHook, getWireSessionStopHook, getWireSessionStopHookCcSemantics, buildGoalStopHookPrompt, } from './goalStopHook.js';
@@ -37,6 +37,40 @@ function nonManagedDisableAllHooks(settings) {
     }
     return false;
 }
+const HOOKS_STARTUP_MODES = ['safe', 'bare'];
+const _startupModesPin = [true, true];
+void _startupModesPin;
+function describeStartupModeValue(v) {
+    if (v === null)
+        return 'null';
+    if (typeof v === 'string')
+        return JSON.stringify(v.length > 40 ? `${v.slice(0, 40)}…` : v);
+    return typeof v;
+}
+function startupModeWord(settings) {
+    let v;
+    try {
+        const member = settings.hooksStartupMode;
+        if (member === undefined)
+            return undefined;
+        if (typeof member !== 'function') {
+            hostLog('debug', `hooksWireCaps: hooksStartupMode is ${describeStartupModeValue(member)}, not a method — treated as neither safe nor bare mode (settings hooks not narrowed)`);
+            return undefined;
+        }
+        v = member.call(settings);
+    }
+    catch (err) {
+        hostLog('debug', `hooksWireCaps: hooksStartupMode() threw — treated as neither safe nor bare mode (settings hooks not narrowed): ${String(err)}`);
+        return undefined;
+    }
+    if (v === undefined)
+        return undefined;
+    const word = HOOKS_STARTUP_MODES.find((w) => w === v);
+    if (word !== undefined)
+        return word;
+    hostLog('debug', `hooksWireCaps: hooksStartupMode() returned ${describeStartupModeValue(v)}, which is neither 'safe' nor 'bare' — treated as neither mode (settings hooks not narrowed)`);
+    return undefined;
+}
 function hooksOfSource(source) {
     try {
         const s = hostSettings()?.getSettingsForSource(source);
@@ -203,8 +237,27 @@ function buildHooksWirePlan(engine, shellEvents, withPlugins) {
         hostLog('debug', 'hooksWireCaps: disableAllHooks (merged, non-managed) — only policySettings hooks projected to the engine');
     }
     const managedOnly = managedByPolicy || disabledByNonManaged;
-    const sources = managedOnly ? ['policySettings'] : ALL_HOOK_SOURCES;
+    const read = withPlugins ? readPluginHooks(settings, true) : undefined;
+    let oldStartupBit;
+    let pluginDataThrew = false;
+    if (read?.reading !== undefined) {
+        const reading = read.reading;
+        const bit = guardPluginTraversal(() => reading.suppressedByStartupMode === true);
+        if (bit === undefined)
+            pluginDataThrew = true;
+        else
+            oldStartupBit = bit;
+    }
+    const startupMode = startupModeWord(settings) ?? (oldStartupBit === true ? 'safe' : undefined);
+    if (startupMode === 'bare') {
+        hostLog('debug', 'hooksWireCaps: bare mode reported by the host — only policySettings hooks projected to the engine (same as safe mode)');
+    }
+    else if (startupMode === 'safe') {
+        hostLog('debug', 'hooksWireCaps: safe mode reported by the host — only policySettings hooks projected to the engine');
+    }
+    const sources = managedOnly || startupMode !== undefined ? ['policySettings'] : ALL_HOOK_SOURCES;
     const merged = {};
+    const sourced = new Map();
     for (const source of sources) {
         const hooks = hooksOfSource(source);
         if (!hooks)
@@ -218,8 +271,20 @@ function buildHooksWirePlan(engine, shellEvents, withPlugins) {
             if (kept.groups.length === 0)
                 continue;
             merged[event] = [...(merged[event] ?? []), ...kept.groups];
+            const tagged = sourced.get(event) ?? [];
+            for (const group of kept.groups)
+                tagged.push({ source, group });
+            sourced.set(event, tagged);
         }
     }
+    let settingsDeduped = 0;
+    for (const [event, groups] of sourced) {
+        const d = dedupeSettingsHookGroups(groups);
+        if (d.removed === 0)
+            continue;
+        merged[event] = d.groups;
+        settingsDeduped += d.removed;
+    }
     const goalMatcher = goalStopHookMatcher(managedOnly);
     if (goalMatcher !== null) {
         merged['Stop'] = [...(merged['Stop'] ?? []), goalMatcher];
@@ -228,6 +293,10 @@ function buildHooksWirePlan(engine, shellEvents, withPlugins) {
         hostLog('debug', `hooksWireCaps: ${settingsDropped.length} settings hook entr${settingsDropped.length === 1 ? 'y' : 'ies'} not sent to the engine ` +
             `(${[...new Set(settingsDropped.map((d) => d.reason))].join(', ')}) — see hooksWirePlan().settingsDropped`);
     }
+    if (settingsDeduped > 0) {
+        hostLog('debug', `hooksWireCaps: ${settingsDeduped} settings hook entr${settingsDeduped === 1 ? 'y appears' : 'ies appear'} more than once ` +
+            '(same event, matcher group and hook) — sent once, at the first position, with the fields of the highest-precedence source');
+    }
     if (settingsStripped > 0) {
         hostLog('debug', `hooksWireCaps: ${settingsStripped} settings hook entr${settingsStripped === 1 ? 'y' : 'ies'} carried a plugin key — ` +
             'stripped before sending (plugin context is only minted for entries from the plugin reader)');
@@ -250,18 +319,19 @@ function buildHooksWirePlan(engine, shellEvents, withPlugins) {
         }
         return planOf('absent', wireOf());
     }
-    const read = readPluginHooks(settings, true);
-    if (read.reading === undefined)
-        return planOf(read.state, wireOf());
+    if (read?.reading === undefined)
+        return planOf(read?.state ?? 'absent', wireOf());
+    if (pluginDataThrew)
+        return planOf('failed', wireOf());
     const reading = read.reading;
     const occupied = occupancyOf(merged);
     const d = guardPluginTraversal(() => {
         const plugins = reading.plugins;
-        const startupMode = reading.suppressedByStartupMode === true;
-        const managedOnlyPlugins = !startupMode && plugins.length > 0 && (policy?.allowManagedHooksOnly === true || mergedDisable());
+        const startup = startupMode !== undefined;
+        const managedOnlyPlugins = !startup && plugins.length > 0 && (policy?.allowManagedHooksOnly === true || mergedDisable());
         return decidePluginHooks({
             plugins,
-            exclusion: startupMode ? 'startup_mode' : undefined,
+            exclusion: startup ? 'startup_mode' : undefined,
             managedOnly: managedOnlyPlugins,
             engine,
             shellHookEvents: shellEvents,

package/dist/host.d.ts

@@ -7,7 +7,9 @@ export interface SettingsPort {
     shouldSkipHookDueToTrust(hook?: unknown): boolean;
     mergedDisableAllHooks?(): boolean | undefined;
     enabledPluginHooks?(): PluginHooksReading;
+    hooksStartupMode?(): HooksStartupMode | undefined;
 }
+export type HooksStartupMode = 'safe' | 'bare';
 export type PluginHookOptionValue = string | number | boolean;
 export interface PluginHookSensitiveOption {
     readonly sensitive: true;

package/dist/index.d.ts

@@ -57,8 +57,8 @@ export * from './modelCapabilityProbe.js';
 export * from './classifierStatus.js';
 export * from './engineToolLabelStore.js';
 export * from './fleetTaskDesc.js';
-export { displayUntrusted } from './displayUntrusted.js';
-export type { DisplayUntrustedOptions, DisplayMark } from './displayUntrusted.js';
+export { displayUntrusted, displayUntrustedMarks } from './displayUntrusted.js';
+export type { DisplayUntrustedOptions, DisplayMark, DisplayMarkSpan, DisplayUntrustedMarked } from './displayUntrusted.js';
 export type * from './types/engineState.js';
 export * from './hostEnv.js';
 export * from './unrefTimer.js';

package/dist/index.js

@@ -57,7 +57,7 @@ export * from './modelCapabilityProbe.js';
 export * from './classifierStatus.js';
 export * from './engineToolLabelStore.js';
 export * from './fleetTaskDesc.js';
-export { displayUntrusted } from './displayUntrusted.js';
+export { displayUntrusted, displayUntrustedMarks } from './displayUntrusted.js';
 export * from './hostEnv.js';
 export * from './unrefTimer.js';
 export * from './controlRouter.js';

package/dist/pluginHooksWire.d.ts

@@ -84,6 +84,15 @@ export interface SettingsHookFilterResult {
     readonly drops: SettingsHookDrop[];
     readonly stripped: number;
 }
+export interface SourcedSettingsHookGroup {
+    readonly source: HookSettingsSource;
+    readonly group: WireHookGroup;
+}
+export declare function dedupeSettingsHookGroups(groups: readonly SourcedSettingsHookGroup[]): SettingsHookDedupResult;
+export interface SettingsHookDedupResult {
+    readonly groups: WireHookGroup[];
+    readonly removed: number;
+}
 export declare function pluginHookVerdictOf(plan: HooksWirePlan, pluginId: string, event: string, groupIndex: number, hookIndex: number): PluginHookVerdict | undefined;
 export declare function pluginHookReasonText(reason: PluginHookReason): string;
 export declare function settingsHookDropText(reason: SettingsHookDropReason): string;

package/dist/pluginHooksWire.js

@@ -305,6 +305,125 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
     });
     return { groups: out, drops, stripped };
 }
+function settingsHookEntryKey(entry) {
+    if (!isRecord(entry) || typeof entry.type !== 'string')
+        return undefined;
+    const cond = entry.if;
+    if (cond !== undefined && typeof cond !== 'string')
+        return undefined;
+    const ifKey = cond ?? '';
+    const str = (v) => typeof v === 'string';
+    const shell = entry.shell;
+    try {
+        switch (entry.type) {
+            case 'command':
+                if (!str(entry.command) || (shell !== undefined && !str(shell)))
+                    return undefined;
+                return JSON.stringify(['command', shell ?? null, entry.command, entry.args ?? null, ifKey]);
+            case 'prompt':
+            case 'agent':
+                return str(entry.prompt) ? JSON.stringify([entry.type, entry.prompt, ifKey]) : undefined;
+            case 'http':
+                return str(entry.url) ? JSON.stringify(['http', entry.url, ifKey]) : undefined;
+            case 'mcp_tool':
+                return str(entry.server) && str(entry.tool)
+                    ? JSON.stringify(['mcp_tool', entry.server, entry.tool, entry.input ?? {}, ifKey])
+                    : undefined;
+            case 'script': {
+                const script = entry.script;
+                const file = entry.file;
+                if ((script !== undefined && !str(script)) || (file !== undefined && !str(file)) || (script === undefined && file === undefined))
+                    return undefined;
+                return JSON.stringify(['script', script ?? null, file ?? null, ifKey]);
+            }
+            default:
+                return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+function ccMergeRank(source) {
+    switch (source) {
+        case 'userSettings':
+            return 0;
+        case 'projectSettings':
+            return 1;
+        case 'localSettings':
+            return 2;
+        case 'flagSettings':
+            return 3;
+        case 'policySettings':
+            return 4;
+    }
+}
+export function dedupeSettingsHookGroups(groups) {
+    const keysOf = [];
+    const winner = new Map();
+    for (const { source, group } of groups) {
+        if (!isRecord(group) || !Array.isArray(group.hooks)) {
+            keysOf.push([]);
+            continue;
+        }
+        let groupKey;
+        try {
+            const { hooks: _hooks, ...rest } = group;
+            void _hooks;
+            groupKey = JSON.stringify(rest);
+        }
+        catch {
+            groupKey = undefined;
+        }
+        const rank = ccMergeRank(source);
+        const keys = [];
+        for (const entry of group.hooks) {
+            const entryKey = groupKey === undefined ? undefined : settingsHookEntryKey(entry);
+            const key = entryKey === undefined ? undefined : `${groupKey}\u0000${entryKey}`;
+            keys.push(key);
+            if (key === undefined)
+                continue;
+            const prev = winner.get(key);
+            if (prev === undefined || rank >= prev.rank)
+                winner.set(key, { entry, rank });
+        }
+        keysOf.push(keys);
+    }
+    const placed = new Set();
+    const out = [];
+    let removed = 0;
+    groups.forEach(({ group }, gi) => {
+        if (!isRecord(group) || !Array.isArray(group.hooks)) {
+            out.push(group);
+            return;
+        }
+        const keys = keysOf[gi] ?? [];
+        const kept = [];
+        let changed = false;
+        group.hooks.forEach((entry, hi) => {
+            const key = keys[hi];
+            if (key === undefined) {
+                kept.push(entry);
+                return;
+            }
+            if (placed.has(key)) {
+                removed++;
+                changed = true;
+                return;
+            }
+            placed.add(key);
+            const win = winner.get(key)?.entry ?? entry;
+            if (win !== entry)
+                changed = true;
+            kept.push(win);
+        });
+        if (!changed)
+            out.push(group);
+        else if (kept.length > 0)
+            out.push({ ...group, hooks: kept });
+    });
+    return { groups: out, removed };
+}
 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);
 }

package/dist/request/taskRequest.js

@@ -19,7 +19,7 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'council', lanes: ['interactive', 'print'], live: true, why: 'code-review council 形开关(server 读 `=== true`;非 true 不 stamp=与缺席同义,发小的那个)', whyUtilityLane: '无座:场景键;side-channel 不走场景' },
     { field: 'debate', lanes: ['interactive', 'print'], live: true, why: 'council 的 debate 变体开关(server 读 `=== true`)', whyUtilityLane: '无座:场景键;side-channel 不走场景' },
     { field: 'rounds', lanes: ['interactive', 'print'], live: true, why: 'debate 轮数(server clamp [1,3],非有限数被 server 归 undefined——本层原样透传不预 clamp)', whyUtilityLane: '无座:场景键;side-channel 不走场景' },
-    { field: 'lenses', lanes: ['interactive', 'print'], live: true, why: 'code-review 镜头集(passthrough 同 repo;形状由 server 场景定义,本层不闭集)', whyUtilityLane: '无座:场景键;side-channel 不走场景' },
+    { field: 'lenses', lanes: ['interactive', 'print'], live: true, why: 'code-review 镜头数(server 场景按数字读、非数字回 400;本层型面仍按旧形声明为字符串数组 —— 已知不一致,随该族退役处理)', whyUtilityLane: '无座:场景键;side-channel 不走场景' },
     { field: 'memoryCapture', lanes: ['interactive', 'print', 'utility'], live: true, why: '本会话永远不进长期记忆的**声明形**(server §12.4 body 键,单成员闭集 "off");每条车道都是提交面 ⇒ 都能声明。与 memoryWrite:false 不是一个轴(那是「本 run 只读平面」)。⚠️ parked 续跑腿结构性拿不到声明(决策/续跑端点从持久 body 重建 spec),那是引擎侧事实,不是本层的漏', whyUtilityLane: '有座:side-channel 提交是壳自己的一次性问答,**绝不该**进用户的长期记忆 —— 这一位正是那句声明,且它是收紧方向,带上去只会更严' },
     { field: 'memory', lanes: ['interactive', 'print', 'utility'], live: true, why: '这一次运行不挂记忆面的**请求级**开关(server §12.7 body 键,单成员闭集 "off");每条车道都是提交面 ⇒ 都能声明。与 memoryCapture(采集面)不是一个轴、可并存;与 memoryWrite:false(只读平面)也不是一个轴', whyUtilityLane: '有座:side-channel 提交不需要挂记忆面(不挂记忆段 / 索引 / 三只记忆工具),省 token 且零记忆写入;与 memoryCapture 不是一个轴,两条都带' },
     { field: 'approverPosture', lanes: ['interactive', 'print'], live: true, why: '宿主对这个 run 的**审批姿态声明**(「这个 run 的审批卡由我自己自动答」;单成员闭集 `"bypass"`)。🔴 它不授权任何东西、也不是一只门:引擎只把这句声明**渲**给模型(它自己的标记块,首个回合),没有任何裁决腿读它 —— 与 `permissionMode` 的 `bypassPermissions`(选门的形状)**不是一回事**,两键在请求体上各自原样过境、**互不派生**:宿主完全可以一边留着缺省权限模式、一边自己自动答这个 run 的审批卡。🔴 **声明它的唯一条件是「宿主确实自己自动答这个 run 的审批卡」,不许据此推导或改动 `permissionMode`** —— 拿这一位当理由去把门放宽,是把一句只渲给模型看的话读成了授权。宿主并不自动答卡却声明了它 ⇒ 那是对模型说了一句与实际不符的话,修法是**别声明**,不是去动门。加座的理由是**一个事实一处铸点**:同样一句话,要么由引擎在它自己的标记块里说,要么由壳把提醒形文本拼进本 turn 的输入 —— 后者在模型眼里是一段**没有引擎标记**的提醒形副本,按标记声明它该当**数据**处理并报出来。所以壳从此停拼,交这一位。两条用户车道都是提交面 ⇒ 都能声明。坏词由引擎响亮拒(单成员闭集,打错字不许被折成缺席),本层同律在构造期就拒(见 `refuseBadApproverPosture`)。⚠️ 上游的**提交体**与**引擎规格**两层都真读这一键,而装着的 sdk 型面尚未镜像它 ⇒ 本层的字面按提交体的形声明,不从 sdk 取型', whyUtilityLane: '无座:审批姿态是**用户**对他自己那条会话的声明,而 side-channel 是壳自己的提交 —— 把用户的 bypass 姿态带进一条他没参与的提交,等于替他重申一句他没说过的话;况且零工具面根本产不出审批卡' },