@co0ontty/wand 4.83.1 → 4.84.0

package/dist/pi-session-settings.js

@@ -0,0 +1,166 @@
+/** Shared, data-only contract for per-session Pi settings. */
+export const PI_BUILTIN_TOOLS = ["read", "bash", "edit", "write", "grep", "find", "ls"];
+/**
+ * pi-goal 注册的工具名。Pi 的 `--tools` 是白名单（会替换默认集合），所以 CLI 会话要开启目标模式
+ * 必须逐个点名；名字与 `core-extension-host.ts` 的排除列表保持同一份。
+ */
+export const PI_GOAL_TOOLS = ["create_goal", "get_goal", "update_goal"];
+export function piSkillMode(settings, id) {
+    return !settings.resources?.skills.includes(id) ? "off" : settings.lockedSkills?.includes(id) ? "locked" : "on";
+}
+/** A single manual gesture changes selection and lock atomically, never mutating its snapshot. */
+export function piSkillModePatch(settings, id, mode) {
+    const resources = settings.resources ?? { skills: [], mcpServers: [] };
+    const locks = settings.lockedSkills ?? [];
+    return {
+        resources: { ...resources, skills: mode === "off" ? resources.skills.filter((value) => value !== id)
+                : [...new Set([...resources.skills, id])] },
+        lockedSkills: mode === "locked" ? [...new Set([...locks, id])] : locks.filter((value) => value !== id),
+    };
+}
+export function patchPiResourceSelection(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        throw new Error("请选择有效的 Skills / MCP 列表。");
+    const item = raw;
+    if (Object.keys(item).some((key) => key !== "skills" && key !== "mcpServers")) {
+        throw new Error("资源选择不能包含路径、命令或其他设置。");
+    }
+    const ids = (key) => {
+        const value = item[key];
+        if (!Array.isArray(value) || value.length > 64 || new Set(value).size !== value.length
+            || value.some((id) => typeof id !== "string" || !/^(?:skill-[a-f0-9]{24}|mcp-[a-f0-9]{24})$/.test(id))) {
+            throw new Error("资源选择必须是无重复的已安装资源 ID（每类最多64项）。");
+        }
+        return [...value];
+    };
+    return { skills: ids("skills"), mcpServers: ids("mcpServers") };
+}
+export function defaultPiSessionSettings(autoCompaction = true) {
+    return { codemode: "off", globalTools: false, goalMode: false,
+        tools: ["read", "bash", "edit", "write"], localDecision: true, autoCompaction };
+}
+/**
+ * CLI 会话的出厂默认：完全跟随 Pi 自身配置（默认工具 + 已安装的全局扩展 + codemode），
+ * 与直接在终端里跑 `pi` 一致——用户已经装好的子代理、待办、CodeMode 不该因为从 Wand 启动就消失。
+ * 想逐项挑选工具时再关掉「全局扩展工具」，会话就切到 Wand 托管的 `--tools` 白名单。
+ * 进程内 SDK 会话仍用 `defaultPiSessionSettings`：员工会话不静默继承用户的全局扩展。
+ */
+export function defaultPiCliSessionSettings(autoCompaction = true) {
+    return { ...defaultPiSessionSettings(autoCompaction), globalTools: true,
+        resources: { skills: [], mcpServers: [] }, autoResources: false };
+}
+/** Strict partial updates: an invalid/unknown field never silently enables a capability. */
+export function patchPiSessionSettings(current, raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        throw new Error("Pi 设置必须是对象。");
+    const next = { ...current, tools: [...current.tools] };
+    for (const [key, value] of Object.entries(raw)) {
+        if (key === "codemodeOverride") {
+            if (value === null)
+                delete next.codemodeOverride;
+            else if (value === "off" || value === "on" || value === "only")
+                next.codemodeOverride = value;
+            else
+                throw new Error("CodeMode 请选择跟随 Pi、关闭、启用或仅 CodeMode。");
+        }
+        else if (key === "resources") {
+            next.resources = patchPiResourceSelection(value);
+        }
+        else if (key === "lockedSkills") {
+            if (!Array.isArray(value) || value.length > 64 || new Set(value).size !== value.length
+                || value.some((id) => typeof id !== "string" || !/^skill-[a-f0-9]{24}$/.test(id))) {
+                throw new Error("锁定技能必须是无重复的已安装 Skill ID（最多64项）。");
+            }
+            next.lockedSkills = [...value];
+        }
+        else if (key === "codemode") {
+            if (value !== "off" && value !== "on" && value !== "only")
+                throw new Error("CodeMode 必须是 off、on 或 only。");
+            next.codemode = value;
+        }
+        else if (key === "tools") {
+            if (!Array.isArray(value) || value.length > PI_BUILTIN_TOOLS.length
+                || value.some((tool) => !PI_BUILTIN_TOOLS.includes(tool)) || new Set(value).size !== value.length) {
+                throw new Error("基础工具必须是无重复的 Pi 工具列表。");
+            }
+            next.tools = [...value];
+        }
+        else if (key === "globalTools" || key === "goalMode" || key === "localDecision" || key === "autoCompaction" || key === "autoResources") {
+            if (typeof value !== "boolean")
+                throw new Error(`${key} 必须是是否启用（boolean）。`);
+            next[key] = value;
+        }
+        else {
+            throw new Error(`未知 Pi 设置：${key}`);
+        }
+    }
+    return next;
+}
+/**
+ * `codemode: "only"`（连声明都藏起来、只从脚本调用）由 Pi 的 `codemode.mode` 设置决定，
+ * 没有对应的 CLI 开关：CLI 会话一律按「启用」处理，读取时也归一到 `on`，不谎报模式。
+ */
+export function cliCodemode(codemode) {
+    return codemode === "off" ? "off" : "on";
+}
+/** 会话设置在该引擎下真正生效的形态（目前只有 CLI 的 CodeMode 需要归一）。 */
+export function effectivePiSessionSettings(settings, engine) {
+    return engine === "cli" ? { ...settings, codemode: cliCodemode(settings.codemode) } : settings;
+}
+export function piToolSelection(settings) {
+    if (settings.globalTools)
+        return { mode: "config", names: [] };
+    const names = [...settings.tools];
+    const codemode = settings.codemodeOverride ?? cliCodemode(settings.codemode);
+    if (codemode !== "off")
+        names.push("codemode");
+    if (settings.goalMode)
+        names.push(...PI_GOAL_TOOLS);
+    return { mode: "allowlist", names };
+}
+export const NO_PI_SETTINGS_CONTROLS = Object.freeze({
+    tools: false, codemode: false, codemodeOnly: false, globalTools: false,
+    goalMode: false, localDecision: false, autoCompaction: false,
+});
+/**
+ * 面板逐项可用性。新服务端直接给 `controls`；没有这个字段的旧服务端按它当时的语义退回：
+ * SDK 原生开关看 `available`，CLI 只开放基础工具列表，其余一律不可改。
+ */
+export function piSettingsControls(response) {
+    if (!response)
+        return NO_PI_SETTINGS_CONTROLS;
+    if (response.controls)
+        return response.controls;
+    const sdk = response.available === true;
+    return {
+        tools: sdk || response.toolsAvailable === true,
+        codemode: sdk,
+        codemodeOnly: sdk,
+        globalTools: sdk,
+        goalMode: sdk && response.goalAvailable === true,
+        localDecision: sdk && response.localDecisionAvailable === true,
+        autoCompaction: sdk,
+    };
+}
+/** CLI 会话能表达的设置字段；其余字段只对进程内 SDK 会话有意义。 */
+export const PI_CLI_SETTING_KEYS = ["tools", "codemode", "globalTools", "goalMode", "localDecision", "resources", "lockedSkills", "codemodeOverride", "autoResources"];
+/**
+ * CLI 会话的写入裁决：无法表达的字段/取值直接拒绝，不能存下一条永远不会生效的设置。
+ * 返回拒绝原因，允许时返回 null。
+ */
+export function cliPiSettingsRejection(raw, next) {
+    const keys = raw && typeof raw === "object" && !Array.isArray(raw) ? Object.keys(raw) : [];
+    const unsupported = keys.filter((key) => !PI_CLI_SETTING_KEYS.includes(key));
+    if (unsupported.length) {
+        return `Pi CLI 会话不支持这些设置：${unsupported.join("、")}（仅原生 SDK 可用）。`;
+    }
+    if (keys.includes("codemode") && next.codemode === "only") {
+        return "「仅 CodeMode」需要原生 SDK；CLI 会话只能选择启用或关闭。";
+    }
+    return null;
+}
+/** Only settings commands, never paths, extension commands, or ordinary slash-prefixed text. */
+export function isPiSettingsDraft(text) {
+    const value = text.trim();
+    return value === "/" || ["/settings", "/codemode", "/tools", "/goal-mode"].some((command) => value.length > 1 && command.startsWith(value));
+}

package/dist/platform-action-catalog.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 平台动作注册表与严格输入校验（IM-07）。
+ * validateActionInput 是所有调用方（HTTP/CLI/原生工具/CodeMode）共用的唯一校验入口；
+ * 任何适配器都不得绕过 invokePlatformAction 另造执行通路。
+ */
+import { type PlatformActionDefinition, type PlatformActionError, type StrictObjectSchema } from "./platform-action-types.js";
+export declare class PlatformActionRegistry {
+    private readonly definitions;
+    /** 定义与自身安全属性矛盾时抛错，防止元数据谎报“只读/免费”。 */
+    register(definition: PlatformActionDefinition): void;
+    get(name: string): PlatformActionDefinition | null;
+    has(name: string): boolean;
+    list(): PlatformActionDefinition[];
+}
+export type ActionInput = Record<string, unknown>;
+export interface ValidatedActionInput {
+    ok: boolean;
+    value?: ActionInput;
+    error?: PlatformActionError;
+}
+/** 根输入必须是普通 JSON 对象；未知键、缺失必填、类型/取值错误逐层拒绝。 */
+export declare function validateActionInput(definition: PlatformActionDefinition, input: unknown): ValidatedActionInput;
+export declare const EMPLOYEE_SEARCH_INPUT_SCHEMA: StrictObjectSchema;
+export declare const EMPLOYEE_SEARCH_DEFINITION: PlatformActionDefinition;

package/dist/platform-action-catalog.js

@@ -0,0 +1,141 @@
+/**
+ * 平台动作注册表与严格输入校验（IM-07）。
+ * validateActionInput 是所有调用方（HTTP/CLI/原生工具/CodeMode）共用的唯一校验入口；
+ * 任何适配器都不得绕过 invokePlatformAction 另造执行通路。
+ */
+import { PLATFORM_ACTION_SCHEMA_VERSION, } from "./platform-action-types.js";
+const ACTION_NAME_RE = /^[a-z][a-z0-9_-]*(\.[a-z][a-z0-9_-]*)*$/;
+export class PlatformActionRegistry {
+    definitions = new Map();
+    /** 定义与自身安全属性矛盾时抛错，防止元数据谎报“只读/免费”。 */
+    register(definition) {
+        if (!ACTION_NAME_RE.test(definition.name))
+            throw new Error(`动作名不合法: ${definition.name}`);
+        if (definition.schemaVersion < 1)
+            throw new Error(`动作 ${definition.name} 缺少有效 schemaVersion`);
+        if (!definition.summary.trim())
+            throw new Error(`动作 ${definition.name} 缺少说明`);
+        if (definition.scopes.length === 0)
+            throw new Error(`动作 ${definition.name} 必须声明所需 scope`);
+        if (definition.inputSchema.type !== "object" || definition.inputSchema.additionalProperties !== false) {
+            throw new Error(`动作 ${definition.name} 的输入 schema 必须 additionalProperties:false`);
+        }
+        if (definition.kind === "read" && (definition.requiresConfirmation || definition.chargesModel)) {
+            throw new Error(`只读动作 ${definition.name} 不得声明确认或模型费用`);
+        }
+        if (definition.kind !== "read" && !definition.requiresConfirmation) {
+            throw new Error(`写/执行动作 ${definition.name} 必须 requiresConfirmation`);
+        }
+        if (this.definitions.has(definition.name))
+            throw new Error(`动作重复注册: ${definition.name}`);
+        this.definitions.set(definition.name, definition);
+    }
+    get(name) {
+        return this.definitions.get(name) ?? null;
+    }
+    has(name) { return this.definitions.has(name); }
+    list() { return [...this.definitions.values()]; }
+}
+function err(code, message, field) {
+    return field === undefined ? { code, message } : { code, message, field };
+}
+function validateNode(schema, value, field) {
+    switch (schema.type) {
+        case "object": {
+            if (typeof value !== "object" || value === null || Array.isArray(value)) {
+                return err("invalid_type", `字段 ${field || "input"} 必须是对象。`, field || undefined);
+            }
+            const record = value;
+            for (const required of schema.required ?? []) {
+                if (!(required in record))
+                    return err("missing_required_field", `缺少必填字段 ${required}。`, required);
+            }
+            for (const key of Object.keys(record)) {
+                if (!(key in schema.properties))
+                    return err("unknown_field", `参数字段 ${key} 未定义，已拒绝。`, key);
+            }
+            for (const [key, child] of Object.entries(schema.properties)) {
+                if (!(key in record))
+                    continue;
+                const childField = field ? `${field}.${key}` : key;
+                const failure = validateNode(child, record[key], childField);
+                if (failure)
+                    return failure;
+            }
+            return null;
+        }
+        case "string": {
+            if (typeof value !== "string")
+                return err("invalid_type", `字段 ${field} 必须是文字。`, field);
+            if (schema.minLength !== undefined && value.length < schema.minLength) {
+                return err("invalid_value", `字段 ${field} 长度不足。`, field);
+            }
+            if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+                return err("invalid_value", `字段 ${field} 超出长度上限 ${schema.maxLength}。`, field);
+            }
+            if (schema.enum && !schema.enum.includes(value)) {
+                return err("invalid_value", `字段 ${field} 不在允许的取值内。`, field);
+            }
+            return null;
+        }
+        case "integer": {
+            if (typeof value !== "number" || !Number.isInteger(value)) {
+                return err("invalid_type", `字段 ${field} 必须是整数。`, field);
+            }
+            if (schema.minimum !== undefined && value < schema.minimum) {
+                return err("invalid_value", `字段 ${field} 不能小于 ${schema.minimum}。`, field);
+            }
+            if (schema.maximum !== undefined && value > schema.maximum) {
+                return err("invalid_value", `字段 ${field} 不能大于 ${schema.maximum}。`, field);
+            }
+            return null;
+        }
+        case "boolean": {
+            return typeof value === "boolean" ? null : err("invalid_type", `字段 ${field} 必须是布尔值。`, field);
+        }
+        case "array": {
+            if (!Array.isArray(value))
+                return err("invalid_type", `字段 ${field} 必须是数组。`, field);
+            if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+                return err("invalid_value", `字段 ${field} 条目数超过上限 ${schema.maxItems}。`, field);
+            }
+            for (let i = 0; i < value.length; i++) {
+                const failure = validateNode(schema.items, value[i], `${field}[${i}]`);
+                if (failure)
+                    return failure;
+            }
+            return null;
+        }
+    }
+}
+/** 根输入必须是普通 JSON 对象；未知键、缺失必填、类型/取值错误逐层拒绝。 */
+export function validateActionInput(definition, input) {
+    if (input !== undefined && (typeof input !== "object" || input === null || Array.isArray(input))) {
+        return { ok: false, error: err("invalid_request", "动作输入必须是 JSON 对象。") };
+    }
+    const value = (input ?? {});
+    const failure = validateNode(definition.inputSchema, value, "");
+    if (failure)
+        return { ok: false, error: failure };
+    return { ok: true, value };
+}
+export const EMPLOYEE_SEARCH_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        query: { type: "string", maxLength: 120 },
+        limit: { type: "integer", minimum: 1, maximum: 50 },
+    },
+    required: [],
+    additionalProperties: false,
+};
+export const EMPLOYEE_SEARCH_DEFINITION = {
+    name: "employee.search",
+    schemaVersion: PLATFORM_ACTION_SCHEMA_VERSION,
+    summary: "按名字、职责、标签只读检索公开员工目录；不读取私人知识与私聊。",
+    group: "people",
+    kind: "read",
+    requiresConfirmation: false,
+    chargesModel: false,
+    scopes: ["employee.search"],
+    inputSchema: EMPLOYEE_SEARCH_INPUT_SCHEMA,
+};

package/dist/platform-action-service.d.ts

@@ -0,0 +1,37 @@
+import { PlatformActionRegistry } from "./platform-action-catalog.js";
+import { type PlatformActionCatalog, type PlatformActorContext, type PlatformActionRequest, type PlatformActionResult } from "./platform-action-types.js";
+export declare const EMPLOYEE_SEARCH_SCOPE: string;
+/** 员工目录的只读投影端口；结构上由 WandStorage.listSiliconEmployees 满足。 */
+export interface EmployeeDirectoryRecord {
+    id: string;
+    name: string;
+    duty: string;
+    tags?: string[];
+    systemKey?: string;
+    archivedAt?: string;
+    agents: readonly unknown[];
+}
+export interface EmployeeDirectoryPort {
+    listSiliconEmployees(options?: {
+        includeArchived?: boolean;
+    }): EmployeeDirectoryRecord[];
+}
+export interface PlatformActionExecContext {
+    actor: PlatformActorContext;
+    deps: PlatformActionDeps;
+}
+export interface PlatformActionDeps {
+    employees: EmployeeDirectoryPort;
+    registry: PlatformActionRegistry;
+}
+export declare function createReadOnlyPlatformActionDeps(employees: EmployeeDirectoryPort): PlatformActionDeps;
+/**
+ * 两阶段发现的目录视图：只返回“本作用域真实已注册且已授予”的动作。
+ * 空权限得到空目录，而不是默认管理员视角；未注册写动作永不出现在这里。
+ */
+export declare function describePlatformCatalog(actor: PlatformActorContext, deps: PlatformActionDeps): PlatformActionCatalog;
+/**
+ * 唯一校验+执行入口。CodeMode 脚本、原生工具、CLI、HTTP 适配器共用本函数，
+ * 不得另造绕过 validateActionInput/scope 检查的执行通路。
+ */
+export declare function invokePlatformAction(request: PlatformActionRequest, actor: PlatformActorContext, deps: PlatformActionDeps): Promise<PlatformActionResult>;

package/dist/platform-action-service.js

@@ -0,0 +1,138 @@
+/**
+ * 只读平台动作服务（IM-07）：能力目录发现 + employee.search 唯一注册动作。
+ * 本模块不接 HTTP/CLI；09/10 的适配器必须调用这里的同一函数。
+ * 身份与授权只来自 PlatformActorContext（可信宿主传入），input 永不参与推导。
+ */
+import { isBuiltinSiliconEmployee, siliconEmployeeTags } from "./ai-team-types.js";
+import { getErrorMessage } from "./error-utils.js";
+import { EMPLOYEE_SEARCH_DEFINITION, PlatformActionRegistry, validateActionInput, } from "./platform-action-catalog.js";
+import { PLATFORM_ACTION_SCHEMA_VERSION, } from "./platform-action-types.js";
+export const EMPLOYEE_SEARCH_SCOPE = EMPLOYEE_SEARCH_DEFINITION.scopes[0];
+const EMPLOYEE_SEARCH_DEFAULT_LIMIT = 20;
+const EMPLOYEE_NAME_MAX_CHARS = 80;
+const EMPLOYEE_DUTY_MAX_CHARS = 200;
+const REQUEST_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
+function fail(code, message, field) {
+    return field === undefined ? { code, message } : { code, message, field };
+}
+function truncate(value, max) {
+    return value.length > max ? value.slice(0, max) : value;
+}
+function executeEmployeeSearch(input, ctx) {
+    const query = typeof input.query === "string" ? input.query.trim().toLowerCase() : "";
+    const limit = typeof input.limit === "number" ? input.limit : EMPLOYEE_SEARCH_DEFAULT_LIMIT;
+    // 默认口径即排除归档；不读取 prompt、知识与任何私人内容。
+    const records = ctx.deps.employees.listSiliconEmployees();
+    const matched = [];
+    for (const record of records) {
+        if (!query) {
+            matched.push(record);
+            continue;
+        }
+        const tags = siliconEmployeeTags(record).map((tag) => tag.toLowerCase());
+        const haystack = [record.name.toLowerCase(), record.duty.toLowerCase(), ...tags];
+        if (haystack.some((part) => part.includes(query)))
+            matched.push(record);
+    }
+    const limited = matched.slice(0, limit);
+    const matches = limited.map((record) => ({
+        employeeId: record.id,
+        name: truncate(record.name, EMPLOYEE_NAME_MAX_CHARS),
+        duty: truncate(record.duty, EMPLOYEE_DUTY_MAX_CHARS),
+        tags: [...siliconEmployeeTags(record)],
+        builtin: isBuiltinSiliconEmployee(record),
+        availability: record.agents.length > 0 ? "available" : "unconfigured",
+    }));
+    const nameCounts = new Map();
+    for (const match of matches)
+        nameCounts.set(match.name, (nameCounts.get(match.name) ?? 0) + 1);
+    return {
+        schemaVersion: PLATFORM_ACTION_SCHEMA_VERSION,
+        matches,
+        totalMatched: matched.length,
+        truncated: matched.length > limited.length,
+        duplicateNames: [...nameCounts.entries()].filter(([, count]) => count >= 2).map(([name]) => name),
+    };
+}
+/** 已注册但此处未接线执行器的动作一律 action_unavailable，不冒充可调用。 */
+const READ_ONLY_EXECUTORS = {
+    [EMPLOYEE_SEARCH_DEFINITION.name]: executeEmployeeSearch,
+};
+export function createReadOnlyPlatformActionDeps(employees) {
+    const registry = new PlatformActionRegistry();
+    registry.register(EMPLOYEE_SEARCH_DEFINITION);
+    return { employees, registry };
+}
+function hasAllScopes(definition, grantedScopes) {
+    const granted = new Set(grantedScopes);
+    return definition.scopes.every((scope) => granted.has(scope));
+}
+/**
+ * 两阶段发现的目录视图：只返回“本作用域真实已注册且已授予”的动作。
+ * 空权限得到空目录，而不是默认管理员视角；未注册写动作永不出现在这里。
+ */
+export function describePlatformCatalog(actor, deps) {
+    const entries = deps.registry
+        .list()
+        .filter((definition) => hasAllScopes(definition, actor.grantedScopes))
+        .map((definition) => ({
+        name: definition.name,
+        schemaVersion: definition.schemaVersion,
+        summary: definition.summary,
+        group: definition.group,
+        kind: definition.kind,
+        requiresConfirmation: definition.requiresConfirmation,
+        chargesModel: definition.chargesModel,
+        scopes: [...definition.scopes],
+        inputSchema: definition.inputSchema,
+        available: true,
+    }));
+    return {
+        schemaVersion: PLATFORM_ACTION_SCHEMA_VERSION,
+        entries,
+        note: "目录仅列出当前授权下真实可调用的已注册动作；未列出的动作（包括任何写操作）不可调用。",
+    };
+}
+/**
+ * 唯一校验+执行入口。CodeMode 脚本、原生工具、CLI、HTTP 适配器共用本函数，
+ * 不得另造绕过 validateActionInput/scope 检查的执行通路。
+ */
+export function invokePlatformAction(request, actor, deps) {
+    const envelope = (schemaVersion) => ({
+        requestId: typeof request?.requestId === "string" ? request.requestId : "",
+        action: typeof request?.action === "string" ? request.action : "",
+        schemaVersion,
+    });
+    const rejected = (error, definition) => Promise.resolve({ ...envelope(definition?.schemaVersion ?? PLATFORM_ACTION_SCHEMA_VERSION), state: "rejected", error });
+    if (request === null || typeof request !== "object" || Array.isArray(request)) {
+        return rejected(fail("invalid_request", "动作请求必须是 JSON 对象。"), null);
+    }
+    if (typeof request.requestId !== "string" || !REQUEST_ID_RE.test(request.requestId)) {
+        return rejected(fail("invalid_request", "requestId 必须是非空、不超过 128 字符的稳定标识。", "requestId"), null);
+    }
+    if (typeof request.action !== "string") {
+        return rejected(fail("invalid_request", "action 必须是字符串。", "action"), null);
+    }
+    const definition = deps.registry.get(request.action);
+    if (!definition) {
+        return rejected(fail("unknown_action", `动作 ${request.action} 未注册，当前不可调用。`, "action"), null);
+    }
+    if (!hasAllScopes(definition, actor.grantedScopes)) {
+        return rejected(fail("scope_denied", `当前授权缺少动作 ${definition.name} 所需 scope。`), definition);
+    }
+    const validated = validateActionInput(definition, request.input);
+    if (!validated.ok || !validated.value) {
+        return rejected(validated.error ?? fail("invalid_request", "动作输入校验失败。"), definition);
+    }
+    const executor = READ_ONLY_EXECUTORS[definition.name];
+    if (!executor) {
+        return rejected(fail("action_unavailable", `动作 ${definition.name} 已注册但当前作用域未启用。`), definition);
+    }
+    try {
+        const output = executor(validated.value, { actor, deps });
+        return Promise.resolve({ ...envelope(definition.schemaVersion), state: "completed", output });
+    }
+    catch (error) {
+        return rejected(fail("internal_error", `动作 ${definition.name} 执行失败：${getErrorMessage(error)}`), definition);
+    }
+}

package/dist/platform-action-types.d.ts

@@ -0,0 +1,125 @@
+/**
+ * 平台动作类型合同（IM-07）。
+ * 合同全文见 output/im-huajie-implementation-20261006/results/07/CONTRACT.md；
+ * 08/09/10/12/13 复用这里的类型与错误码，不再另定义平行信封。
+ */
+/** 动作信封与定义共用的 schema 版本。 */
+export declare const PLATFORM_ACTION_SCHEMA_VERSION = 1;
+export type PlatformActionGroup = "people" | "chat" | "task";
+export type PlatformActionKind = "read" | "write" | "execute";
+export interface StrictObjectSchema {
+    type: "object";
+    properties: Record<string, StrictInputSchemaNode>;
+    required?: string[];
+    additionalProperties: false;
+}
+export type StrictInputSchemaNode = StrictObjectSchema | {
+    type: "string";
+    minLength?: number;
+    maxLength?: number;
+    enum?: readonly string[];
+} | {
+    type: "integer";
+    minimum?: number;
+    maximum?: number;
+} | {
+    type: "boolean";
+} | {
+    type: "array";
+    items: StrictInputSchemaNode;
+    maxItems?: number;
+};
+export interface PlatformActionDefinition {
+    name: string;
+    schemaVersion: number;
+    summary: string;
+    group: PlatformActionGroup;
+    kind: PlatformActionKind;
+    /** read 必须 false；write/execute 必须 true。注册时强制。 */
+    requiresConfirmation: boolean;
+    /** 是否可能触发模型调用；read 必须 false。 */
+    chargesModel: boolean;
+    /** 全部授予才可调用；当前约定 scope 字符串与动作名一致。 */
+    scopes: readonly string[];
+    inputSchema: StrictObjectSchema;
+}
+export type PlatformActorKind = "employee_session" | "conversation_member" | "codemode" | "host";
+/**
+ * 调用者身份与授权只由可信宿主构造；request.input 里的任何同名字段不参与推导，
+ * 且会被严格输入 schema 作为 unknown_field 拒绝。
+ */
+export interface PlatformActorContext {
+    actorKind: PlatformActorKind;
+    /** 可信绑定到的调用员工；null = 无员工身份，不因此获得或失去任何 scope。 */
+    employeeId: string | null;
+    sessionId: string | null;
+    conversationId: string | null;
+    /** 用户权限 ∩ 本次委托 ∩ 引擎/资源限制；空数组 = 无权限，不默认管理员。 */
+    grantedScopes: readonly string[];
+}
+export interface PlatformActionRequest {
+    /** ≤128 字符、[A-Za-z0-9._:-]；write 动作按 requestId+fingerprint 幂等（08）。 */
+    requestId: string;
+    action: string;
+    input?: unknown;
+}
+export type PlatformActionErrorCode = "invalid_request" | "unknown_action" | "scope_denied" | "action_unavailable" | "unknown_field" | "missing_required_field" | "invalid_type" | "invalid_value" | "internal_error";
+export interface PlatformActionError {
+    code: PlatformActionErrorCode;
+    message: string;
+    field?: string;
+}
+export interface PlatformActionCompleted {
+    requestId: string;
+    action: string;
+    schemaVersion: number;
+    state: "completed";
+    output: unknown;
+}
+export interface PlatformActionRejected {
+    requestId: string;
+    action: string;
+    schemaVersion: number;
+    state: "rejected";
+    error: PlatformActionError;
+}
+/**
+ * 只读动作同步产出 completed；write 动作（08+）扩展 needs_confirmation/accepted/
+ * unconfirmed，与 ConversationReceipt 的映射见 CONTRACT.md §5。
+ */
+export type PlatformActionResult = PlatformActionCompleted | PlatformActionRejected;
+export interface PlatformActionCatalogEntry {
+    name: string;
+    schemaVersion: number;
+    summary: string;
+    group: PlatformActionGroup;
+    kind: PlatformActionKind;
+    requiresConfirmation: boolean;
+    chargesModel: boolean;
+    scopes: readonly string[];
+    inputSchema: StrictObjectSchema;
+    /** 目录只列真实已注册且已授予的动作；未注册动作永远不会以可调用出现。 */
+    available: true;
+}
+export interface PlatformActionCatalog {
+    schemaVersion: number;
+    entries: PlatformActionCatalogEntry[];
+    note: string;
+}
+export interface EmployeeSearchMatch {
+    employeeId: string;
+    name: string;
+    duty: string;
+    tags: string[];
+    builtin: boolean;
+    availability: "available" | "unconfigured";
+}
+export interface EmployeeSearchOutput {
+    schemaVersion: number;
+    matches: EmployeeSearchMatch[];
+    /** 截断前命中数。 */
+    totalMatched: number;
+    truncated: boolean;
+    /** matches 内出现 ≥2 次的名字，供上层追问选择。 */
+    duplicateNames: string[];
+}

package/dist/platform-action-types.js

@@ -0,0 +1,7 @@
+/**
+ * 平台动作类型合同（IM-07）。
+ * 合同全文见 output/im-huajie-implementation-20261006/results/07/CONTRACT.md；
+ * 08/09/10/12/13 复用这里的类型与错误码，不再另定义平行信封。
+ */
+/** 动作信封与定义共用的 schema 版本。 */
+export const PLATFORM_ACTION_SCHEMA_VERSION = 1;