@cjhyy/code-shell-pet 0.8.0

package/README.md

@@ -0,0 +1,99 @@
+# @cjhyy/code-shell-pet
+
+CodeShell 的 Mimi（项目工作状态助理 / 桌面 Pet）领域能力包。它只依赖
+`@cjhyy/code-shell-core/extension`，由宿主显式加载，不把 Pet 字面量和产品规则重新写回
+core。
+
+## 为什么单独成包
+
+Mimi 与普通 Work Session 的职责不同：
+
+- Mimi 负责澄清、汇总、路由和跨 Workspace 协调；
+- Work Session 负责读文件、运行工具和完成执行任务；
+- Desktop 负责窗口、导航、磁盘会话目录和具体 UI。
+
+因此 Pet 包只拥有可跨宿主复用的领域规则和投影协议。Electron 窗口、React 组件、磁盘目录
+扫描等宿主能力留在 `packages/desktop`；通用引擎、工具系统和协议生命周期留在
+`packages/core`。
+
+## 模块边界
+
+| 模块                                      | 职责                                                                 |
+| ----------------------------------------- | -------------------------------------------------------------------- |
+| `capability.ts`                           | 唯一组合根：注册行为 profile、DelegateWork、投影 observer 和参数校验 |
+| `profile.ts`                              | Mimi 的系统边界、允许工具和单轮委托服务                              |
+| `delegation.ts` / `delegate-work.ts`      | Workspace、可复用 Session 与结构化委托工具                           |
+| `run-params.ts`                           | 宿主输入的有界校验、规范化和 fail-closed 快照                        |
+| `gateway.ts` / `host-actions.ts`          | 渠道只读发现与当前会话回复，不接收任意 target                        |
+| `outbound-message.ts`                     | 使用宿主不透明目标的主动消息请求；工具接受不等于发送成功             |
+| `follow-ups.ts`                           | 读取/处理 Desktop 同一份“需要跟进”，不建立第二套 Todo                |
+| `sessions-tool.ts` / `session-control.ts` | Session 渐进读取与精确归档选择器                                     |
+| `current-time.ts`                         | 宿主时间原子能力，不让 Mimi 猜 epoch 或调用 shell                    |
+| `team.ts`                                 | 历史兼容的数字人团队纯数据契约；Pet runtime 不消费                   |
+| `session-index.ts`                        | Work Session 的纯状态机与安全摘要                                    |
+| `pending-decision-index.ts`               | 跨 Session 待决策读模型，不持有 resolver 或原始问题正文              |
+| `projection-extension.ts`                 | 把 core 的通用生命周期事件投影为 Pet snapshot/delta                  |
+| `protocol.ts` / `types.ts`                | Pet 专属 wire shape 和领域类型                                       |
+| `long-task.ts`                            | 长程任务状态机、事件协议、恢复提示和有界经理上下文                   |
+
+这种拆分让状态机、输入边界和协议适配可以分别测试，也让 Desktop 以后更换呈现方式时不必改
+Mimi 的安全规则。
+
+## 公共入口
+
+Pet 保持为一个 npm 包，不把 projection 和能力工厂继续拆成多个独立发布单元。新代码
+应按职责使用两个最小子入口：
+
+```ts
+import { createPetCapability } from "@cjhyy/code-shell-pet/capability";
+import {
+  PET_PROJECTION_DELTA_METHOD,
+  type PetProjectionDelta,
+  type PetProjectionSnapshotResult,
+} from "@cjhyy/code-shell-pet/protocol";
+```
+
+| 入口                               | 稳定职责                                    | 不包含                                        |
+| ---------------------------------- | ------------------------------------------- | --------------------------------------------- |
+| `@cjhyy/code-shell-pet/capability` | 宿主组合用的 `createPetCapability`          | prompt、工具实现、状态机                      |
+| `@cjhyy/code-shell-pet/protocol`   | snapshot/delta 方法名和投影 wire types      | `SessionIndex`、pending 状态机、observer 实现 |
+| `@cjhyy/code-shell-pet/team`       | 仅历史兼容；新消费方应使用 Desktop 共享契约 | Pet runtime 或 core 扩展逻辑                  |
+
+根入口 `@cjhyy/code-shell-pet` 为现有 Desktop 和动态 capability loader 保持兼容；它不会被
+移除，但新消费方不应为了一个协议类型或团队 parser 依赖整个兼容 barrel。包不提供通配
+deep import，未列出的源码模块均为内部实现。
+
+## 必须保持的约束
+
+- Mimi 不能获得 Workspace 执行工具；执行工作只能通过 `DelegateWork`。
+- Workspace 和可复用 Session 必须来自宿主本轮提供的闭集。
+- Pet 不接收、保存或路由数字人 / 数字人团队 id；数字人工作归项目 Session。
+- `pet` Session 不得出现在普通 Work Session 列表或待决策列表。
+- 投影不得包含 resolver、工具参数、原始 AskUser 正文、命令或凭证。
+- 畸形宿主输入必须隐藏委托能力或返回错误，不能降级为不受限执行。
+- Pet 包不得运行时依赖 Desktop、TUI、Server、Web 或其他产品包。
+- `DelegateWork` 的启动回执不等于完成；只有真实 Work Session 终态才能关闭长程任务。
+- `GatewayReply`、`SendMessage` 和其他宿主动作只登记请求；成功/失败措辞只能来自宿主执行回执。
+- “需要跟进”只有一个 canonical service 和 durable state；不得重新增加独立 Todo store/tool/UI。
+
+## 长程任务宿主契约
+
+`long-task.ts` 只定义可移植的领域状态机。Desktop 当前负责把它接到真实运行时：
+
+- 每次委派先原子写入 `pet/long-tasks.json`，再启动 Work Session；
+- Work Session 使用 core Goal 模式持续执行，Pet 不复制第二套执行循环；
+- 顶层 stream event 提供 checkpoint 和可信的 `goal_progress(met/exhausted)` 终态，Pet projection 提供待审批/断线状态；
+- 暂停会持久化 Goal 的 paused 状态并停止当前 turn，恢复/重试继续同一 durable Session；
+- 进程重启后，未观察到终态的任务进入 `interrupted`，用户可从原 Session 恢复；
+- 终态先写入去重的工作记忆，再确认交付；中途崩溃会在启动时安全重放；
+- 每个 Mimi turn 只注入有界 `longTasks` 摘要，不回灌完整 transcript 或工具参数。
+
+## 验证
+
+```bash
+bun test packages/pet/src
+bun run --cwd packages/pet build
+bunx eslint packages/pet/src --max-warnings=0
+```
+
+`build` 会先清空 `dist/`，避免删除或重命名源码后把陈旧产物发布出去。

package/dist/capability.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The Pet domain packaged as a self-contained core extension module.
+ *
+ * Hosts opt in explicitly:
+ *   - desktop injects `CODE_SHELL_CAPABILITY_MODULES=@cjhyy/code-shell-pet#createPetCapability`
+ *     into the stdio worker env (loaded by core's agent-server-stdio cli);
+ *   - in-process hosts/tests pass `extensionModules: [createPetCapability()]`
+ *     to EngineConfig / AgentServer options.
+ *
+ * Core itself is pet-free: behavior comes from the generic RunBehaviorProfile
+ * registry, protocol observation from ProtocolObserver, and the DelegateWork
+ * tool joins the composed tool catalog with full exposure metadata.
+ */
+import type { ExtensionModule } from "@cjhyy/code-shell-core/extension";
+export declare function createPetCapability(): ExtensionModule;

package/dist/capability.js

@@ -0,0 +1,251 @@
+/**
+ * The Pet domain packaged as a self-contained core extension module.
+ *
+ * Hosts opt in explicitly:
+ *   - desktop injects `CODE_SHELL_CAPABILITY_MODULES=@cjhyy/code-shell-pet#createPetCapability`
+ *     into the stdio worker env (loaded by core's agent-server-stdio cli);
+ *   - in-process hosts/tests pass `extensionModules: [createPetCapability()]`
+ *     to EngineConfig / AgentServer options.
+ *
+ * Core itself is pet-free: behavior comes from the generic RunBehaviorProfile
+ * registry, protocol observation from ProtocolObserver, and the DelegateWork
+ * tool joins the composed tool catalog with full exposure metadata.
+ */
+import { delegateWorkAvailability, delegateWorkTool, delegateWorkToolDef, rewriteDelegateWorkDef, } from "./delegate-work.js";
+import { mobileRemoteAvailability, mobileRemoteTool, mobileRemoteToolDef, } from "./mobile-remote.js";
+import { gatewayAvailability, gatewayTool, gatewayToolDef } from "./gateway.js";
+import { sessionsAvailability, sessionsTool, sessionsToolDef } from "./sessions-tool.js";
+import { currentTimeAvailability, currentTimeTool, currentTimeToolDef } from "./current-time.js";
+import { manageSessionsAvailability, manageSessionsTool, manageSessionsToolDef, } from "./session-control.js";
+import { followUpsAvailability, followUpsTool, followUpsToolDef, manageFollowUpAvailability, manageFollowUpTool, manageFollowUpToolDef, } from "./follow-ups.js";
+import { rewriteSendMessageDef, sendMessageAvailability, sendMessageTool, sendMessageToolDef, } from "./outbound-message.js";
+import { controlLongTaskAvailability, controlLongTaskTool, controlLongTaskToolDef, gatewayReplyAvailability, gatewayReplyTool, gatewayReplyToolDef, memoryAvailability, memoryTool, memoryToolDef, rewriteGatewayReplyDef, } from "./host-actions.js";
+import { PET_BEHAVIOR_PROFILE } from "./profile.js";
+import { createPetProjectionObserver, PET_HIDDEN_SESSION_KINDS } from "./projection-extension.js";
+import { PET_REPORT_TO_MIMI_METHOD } from "./protocol.js";
+import { reportToMimiAvailability, reportToMimiTool, reportToMimiToolDef, } from "./report-to-mimi.js";
+import { validatePetRunParams } from "./run-params.js";
+export function createPetCapability() {
+    let reportToMimi;
+    const createProtocolObserver = (host) => {
+        reportToMimi = (event) => host.notify(PET_REPORT_TO_MIMI_METHOD, event);
+        const projection = createPetProjectionObserver(host);
+        return {
+            ...projection,
+            onServerClose: () => {
+                reportToMimi = undefined;
+                projection.onServerClose?.();
+            },
+        };
+    };
+    return {
+        id: "pet",
+        behaviorProfiles: [PET_BEHAVIOR_PROFILE],
+        createProtocolObserver,
+        validateRunParams: validatePetRunParams,
+        hiddenSessionKinds: PET_HIDDEN_SESSION_KINDS,
+        catalogTools: [
+            {
+                definition: {
+                    ...reportToMimiToolDef,
+                    source: "builtin",
+                    permissionDefault: "allow",
+                    isReadOnly: false,
+                    isConcurrencySafe: false,
+                },
+                execute: (args, ctx) => reportToMimiTool(args, ctx, reportToMimi),
+                exposure: {
+                    presetTags: ["harness-min", "general"],
+                    defaultPermissionRules: [{ tool: reportToMimiToolDef.name, decision: "allow" }],
+                    availability: reportToMimiAvailability,
+                },
+            },
+            {
+                definition: {
+                    ...delegateWorkToolDef,
+                    source: "builtin",
+                    permissionDefault: "allow",
+                    isReadOnly: false,
+                    isConcurrencySafe: false,
+                },
+                execute: delegateWorkTool,
+                exposure: {
+                    // Byte-identical to the former builtin registration: HARNESS_TAGS
+                    // preset tags + explicit allow rule + pet-profile availability and
+                    // the per-turn workspace-enum rewrite.
+                    presetTags: ["harness-min", "general"],
+                    defaultPermissionRules: [{ tool: delegateWorkToolDef.name, decision: "allow" }],
+                    availability: delegateWorkAvailability,
+                    rewriteDefinition: rewriteDelegateWorkDef,
+                },
+            },
+            {
+                definition: {
+                    ...mobileRemoteToolDef,
+                    source: "builtin",
+                    permissionDefault: "allow",
+                    isReadOnly: false,
+                    isConcurrencySafe: false,
+                },
+                execute: mobileRemoteTool,
+                exposure: {
+                    presetTags: ["harness-min", "general"],
+                    defaultPermissionRules: [{ tool: mobileRemoteToolDef.name, decision: "allow" }],
+                    availability: mobileRemoteAvailability,
+                },
+            },
+            {
+                definition: {
+                    ...controlLongTaskToolDef,
+                    source: "builtin",
+                    permissionDefault: "allow",
+                    isReadOnly: false,
+                    isConcurrencySafe: false,
+                },
+                execute: controlLongTaskTool,
+                exposure: {
+                    presetTags: ["harness-min", "general"],
+                    defaultPermissionRules: [{ tool: controlLongTaskToolDef.name, decision: "allow" }],
+                    availability: controlLongTaskAvailability,
+                },
+            },
+            {
+                definition: {
+                    ...memoryToolDef,
+                    source: "builtin",
+                    permissionDefault: "allow",
+                    isReadOnly: false,
+                    isConcurrencySafe: false,
+                },
+                execute: memoryTool,
+                exposure: {
+                    presetTags: ["harness-min", "general"],
+                    defaultPermissionRules: [{ tool: memoryToolDef.name, decision: "allow" }],
+                    availability: memoryAvailability,
+                },
+            },
+            {
+                definition: {
+                    ...gatewayToolDef,
+                    source: "builtin",
+                    permissionDefault: "allow",
+                    isReadOnly: true,
+                    isConcurrencySafe: true,
+                },
+                execute: gatewayTool,
+                exposure: {
+                    presetTags: ["harness-min", "general"],
+                    defaultPermissionRules: [{ tool: gatewayToolDef.name, decision: "allow" }],
+                    availability: gatewayAvailability,
+                },
+            },
+            {
+                definition: {
+                    ...gatewayReplyToolDef,
+                    source: "builtin",
+                    permissionDefault: "allow",
+                    isReadOnly: false,
+                    isConcurrencySafe: false,
+                },
+                execute: gatewayReplyTool,
+                exposure: {
+                    presetTags: ["harness-min", "general"],
+                    defaultPermissionRules: [{ tool: gatewayReplyToolDef.name, decision: "allow" }],
+                    availability: gatewayReplyAvailability,
+                    rewriteDefinition: rewriteGatewayReplyDef,
+                },
+            },
+            {
+                definition: {
+                    ...sessionsToolDef,
+                    source: "builtin",
+                    permissionDefault: "allow",
+                    isReadOnly: true,
+                    isConcurrencySafe: true,
+                },
+                execute: sessionsTool,
+                exposure: {
+                    presetTags: ["harness-min", "general"],
+                    defaultPermissionRules: [{ tool: sessionsToolDef.name, decision: "allow" }],
+                    availability: sessionsAvailability,
+                },
+            },
+            {
+                definition: {
+                    ...followUpsToolDef,
+                    source: "builtin",
+                    permissionDefault: "allow",
+                    isReadOnly: true,
+                    isConcurrencySafe: true,
+                },
+                execute: followUpsTool,
+                exposure: {
+                    presetTags: ["harness-min", "general"],
+                    defaultPermissionRules: [{ tool: followUpsToolDef.name, decision: "allow" }],
+                    availability: followUpsAvailability,
+                },
+            },
+            {
+                definition: {
+                    ...manageFollowUpToolDef,
+                    source: "builtin",
+                    permissionDefault: "allow",
+                    isReadOnly: false,
+                    isConcurrencySafe: false,
+                },
+                execute: manageFollowUpTool,
+                exposure: {
+                    presetTags: ["harness-min", "general"],
+                    defaultPermissionRules: [{ tool: manageFollowUpToolDef.name, decision: "allow" }],
+                    availability: manageFollowUpAvailability,
+                },
+            },
+            {
+                definition: {
+                    ...manageSessionsToolDef,
+                    source: "builtin",
+                    permissionDefault: "allow",
+                    isReadOnly: false,
+                    isConcurrencySafe: false,
+                },
+                execute: manageSessionsTool,
+                exposure: {
+                    presetTags: ["harness-min", "general"],
+                    defaultPermissionRules: [{ tool: manageSessionsToolDef.name, decision: "allow" }],
+                    availability: manageSessionsAvailability,
+                },
+            },
+            {
+                definition: {
+                    ...currentTimeToolDef,
+                    source: "builtin",
+                    permissionDefault: "allow",
+                    isReadOnly: true,
+                    isConcurrencySafe: true,
+                },
+                execute: currentTimeTool,
+                exposure: {
+                    presetTags: ["harness-min", "general"],
+                    defaultPermissionRules: [{ tool: currentTimeToolDef.name, decision: "allow" }],
+                    availability: currentTimeAvailability,
+                },
+            },
+            {
+                definition: {
+                    ...sendMessageToolDef,
+                    source: "builtin",
+                    permissionDefault: "allow",
+                    isReadOnly: false,
+                    isConcurrencySafe: false,
+                },
+                execute: sendMessageTool,
+                exposure: {
+                    presetTags: ["harness-min", "general"],
+                    defaultPermissionRules: [{ tool: sendMessageToolDef.name, decision: "allow" }],
+                    availability: sendMessageAvailability,
+                    rewriteDefinition: rewriteSendMessageDef,
+                },
+            },
+        ],
+    };
+}

package/dist/current-time.d.ts

@@ -0,0 +1,5 @@
+import type { ToolDefinition, ToolVisibilityContext } from "@cjhyy/code-shell-core/extension";
+export declare const CURRENT_TIME_TOOL_NAME = "CurrentTime";
+export declare const currentTimeToolDef: ToolDefinition;
+export declare function currentTimeAvailability(ctx: ToolVisibilityContext): boolean;
+export declare function currentTimeTool(args: Record<string, unknown>): Promise<string>;

package/dist/current-time.js

@@ -0,0 +1,43 @@
+import { hasOnlyDeclaredToolArguments } from "./tool-arguments.js";
+export const CURRENT_TIME_TOOL_NAME = "CurrentTime";
+export const currentTimeToolDef = {
+    name: CURRENT_TIME_TOOL_NAME,
+    description: "Return the trusted current local date, time, timezone, UTC offset and epoch. Use this instead " +
+        "of guessing from timestamps or trying to run a shell command.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {},
+    },
+};
+export function currentTimeAvailability(ctx) {
+    return ctx.behaviorProfile === "pet";
+}
+export async function currentTimeTool(args) {
+    if (!hasOnlyDeclaredToolArguments(args, []))
+        return "Error: CurrentTime accepts no arguments.";
+    const now = new Date();
+    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+    const parts = new Intl.DateTimeFormat("zh-CN", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        weekday: "long",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hourCycle: "h23",
+    }).format(now);
+    const offsetMinutes = -now.getTimezoneOffset();
+    const sign = offsetMinutes >= 0 ? "+" : "-";
+    const absolute = Math.abs(offsetMinutes);
+    const utcOffset = `${sign}${String(Math.floor(absolute / 60)).padStart(2, "0")}:${String(absolute % 60).padStart(2, "0")}`;
+    return JSON.stringify({
+        epochMs: now.getTime(),
+        iso: now.toISOString(),
+        local: parts,
+        timeZone,
+        utcOffset,
+    });
+}

package/dist/delegate-work.d.ts

@@ -0,0 +1,7 @@
+import type { ToolContext, ToolDefinition, ToolVisibilityContext } from "@cjhyy/code-shell-core/extension";
+import { type PetReusableSessionOption, type PetWorkspaceOption } from "./delegation.js";
+export declare const delegateWorkToolDef: ToolDefinition;
+export declare function delegateWorkAvailability(ctx: ToolVisibilityContext): boolean;
+export declare function rewriteDelegateWorkDef(def: ToolDefinition, ctx: ToolVisibilityContext): ToolDefinition;
+export declare function delegateWorkToolDefFor(workspaces: readonly PetWorkspaceOption[] | undefined, reusableSessions?: readonly PetReusableSessionOption[] | undefined): ToolDefinition;
+export declare function delegateWorkTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;

package/dist/delegate-work.js

@@ -0,0 +1,142 @@
+import { DELEGATE_WORK_TOOL_NAME, isPetWorkExecutionBackend, } from "./delegation.js";
+// Keep the wire/domain type forward-compatible with persisted "codex"
+// decisions, but advertise only backends the current host actually launches.
+const SUPPORTED_DELEGATE_WORK_BACKENDS = ["codeshell"];
+export const delegateWorkToolDef = {
+    name: DELEGATE_WORK_TOOL_NAME,
+    description: "Delegate one execution objective to exactly one host-provided Workspace. " +
+        "Use only as Mimi after deciding that the user's request requires execution. " +
+        "workspace_id must be copied exactly from the available Workspace list.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            workspace_id: {
+                type: "string",
+                description: "Exact opaque Workspace id from the host-provided list.",
+            },
+            objective: {
+                type: "string",
+                description: "Self-contained objective for the Work Session.",
+            },
+            executor: {
+                type: "string",
+                enum: [...SUPPORTED_DELEGATE_WORK_BACKENDS],
+                description: "Execution backend. Omit or use 'codeshell' for a normal Work Session. External Codex execution is not supported by this host and must never be substituted silently.",
+            },
+            session_id: {
+                type: "string",
+                description: "Optional exact id from the reusable Session list.",
+            },
+        },
+        required: ["workspace_id", "objective"],
+    },
+};
+function visibleWorkspaces(ctx) {
+    const workspaces = ctx.profileMeta?.petWorkspaces;
+    return Array.isArray(workspaces) ? workspaces : [];
+}
+function visibleReusableSessions(ctx) {
+    const sessions = ctx.profileMeta?.petReusableSessions;
+    return Array.isArray(sessions) ? sessions : [];
+}
+export function delegateWorkAvailability(ctx) {
+    return ctx.behaviorProfile === "pet" && visibleWorkspaces(ctx).length > 0;
+}
+function inlineDisplay(value, maximum) {
+    return value.replace(/\s+/gu, " ").trim().slice(0, maximum);
+}
+export function rewriteDelegateWorkDef(def, ctx) {
+    const dynamic = delegateWorkToolDefFor(visibleWorkspaces(ctx), visibleReusableSessions(ctx));
+    return { ...def, description: dynamic.description, inputSchema: dynamic.inputSchema };
+}
+export function delegateWorkToolDefFor(workspaces, reusableSessions = []) {
+    const available = workspaces ?? [];
+    const sessions = reusableSessions ?? [];
+    const workspaceListing = available.length
+        ? available
+            .map((workspace) => `- ${JSON.stringify(workspace.id)}: ${inlineDisplay(workspace.name, 256)}${workspace.description ? ` — ${inlineDisplay(workspace.description, 4_096)}` : ""}`)
+            .join("\n")
+        : "- (no Workspace is currently available)";
+    const sessionListing = sessions.length
+        ? sessions
+            .map((session) => `- ${JSON.stringify(session.id)}: ${inlineDisplay(session.name, 256)} (Workspace ${JSON.stringify(session.workspaceId)})${session.description ? ` — ${inlineDisplay(session.description, 4_096)}` : ""}`)
+            .join("\n")
+        : "- (no existing Session is currently eligible for reuse; omit session_id)";
+    const { session_id: _sessionId, ...baseProperties } = delegateWorkToolDef.inputSchema
+        .properties;
+    return {
+        ...delegateWorkToolDef,
+        description: `${delegateWorkToolDef.description}\n\nAvailable Workspaces:\n${workspaceListing}\n\nReusable Sessions:\n${sessionListing}`,
+        inputSchema: {
+            ...delegateWorkToolDef.inputSchema,
+            properties: {
+                ...baseProperties,
+                workspace_id: {
+                    type: "string",
+                    enum: available.map((workspace) => workspace.id),
+                    description: "Exact opaque Workspace id from the available list.",
+                },
+                ...(sessions.length > 0
+                    ? {
+                        session_id: {
+                            type: "string",
+                            enum: sessions.map((session) => session.id),
+                            description: "Optional exact id from the reusable Session list.",
+                        },
+                    }
+                    : {}),
+            },
+        },
+    };
+}
+export async function delegateWorkTool(args, ctx) {
+    const services = ctx?.runScopedServices;
+    const workspaces = Array.isArray(services?.petWorkspaces) ? services.petWorkspaces : undefined;
+    const reusableSessions = Array.isArray(services?.petReusableSessions)
+        ? services.petReusableSessions
+        : undefined;
+    if (!services?.requestPetWorkDelegation || !workspaces || !reusableSessions) {
+        return "Error: DelegateWork is available only in a Mimi manager turn.";
+    }
+    const workspaceId = typeof args.workspace_id === "string" ? args.workspace_id.trim() : "";
+    const objective = typeof args.objective === "string" ? args.objective.trim() : "";
+    const executor = args.executor === undefined ? "codeshell" : args.executor;
+    const reusableSessionId = typeof args.session_id === "string" ? args.session_id.trim() : "";
+    if (!workspaceId)
+        return "Error: workspace_id is required.";
+    if (!objective)
+        return "Error: objective is required.";
+    if (objective.length > 8_000)
+        return "Error: objective is too long (maximum 8000 characters).";
+    if (executor === "codex") {
+        return "Error: the external Codex execution backend is not supported yet; do not substitute a CodeShell Work Session.";
+    }
+    if (!isPetWorkExecutionBackend(executor)) {
+        return `Error: unknown executor ${JSON.stringify(executor)}. Use ${SUPPORTED_DELEGATE_WORK_BACKENDS.map((backend) => JSON.stringify(backend)).join(" or ")}.`;
+    }
+    const workspace = workspaces.find((candidate) => candidate?.id === workspaceId);
+    if (!workspace) {
+        return `Error: unknown workspace_id ${JSON.stringify(workspaceId)}. Copy one exact id from the available Workspace list.`;
+    }
+    const reusableSession = reusableSessionId
+        ? reusableSessions.find((candidate) => candidate?.id === reusableSessionId)
+        : undefined;
+    if (reusableSessionId && !reusableSession) {
+        return `Error: unknown session_id ${JSON.stringify(reusableSessionId)}. Copy one exact id from the reusable Session list or omit session_id.`;
+    }
+    if (reusableSession && reusableSession.workspaceId !== workspaceId) {
+        return "Error: session_id does not belong to workspace_id.";
+    }
+    const decision = services.requestPetWorkDelegation({
+        workspaceId,
+        objective,
+        ...(executor === "codex" ? { executionBackend: "codex" } : {}),
+        ...(reusableSession ? { reusableSessionId: reusableSession.id } : {}),
+    });
+    if (!decision.ok)
+        return `Error: ${decision.error ?? "work delegation was rejected"}`;
+    return reusableSession
+        ? `Delegation accepted for existing Session ${reusableSession.name} in Workspace ${workspace.name}.`
+        : `Delegation accepted for a new Session in Workspace ${workspace.name}.`;
+}

package/dist/delegation.d.ts

@@ -0,0 +1,33 @@
+export declare const DELEGATE_WORK_TOOL_NAME = "DelegateWork";
+/** Closed set of execution backends; extend here and every schema/validation follows. */
+export declare const PET_WORK_EXECUTION_BACKENDS: readonly ["codeshell", "codex"];
+/** Execution backend selected explicitly by Mimi from the user's request. */
+export type PetWorkExecutionBackend = (typeof PET_WORK_EXECUTION_BACKENDS)[number];
+export declare function isPetWorkExecutionBackend(value: unknown): value is PetWorkExecutionBackend;
+/** Host-provided closed set visible to Mimi for one manager turn. */
+export interface PetWorkspaceOption {
+    id: string;
+    name: string;
+    description?: string;
+}
+/** Host-provided closed set of existing Work Sessions Mimi may continue. */
+export interface PetReusableSessionOption {
+    /** Opaque turn-scoped selector; never an unvalidated model-authored Session id. */
+    id: string;
+    workspaceId: string;
+    name: string;
+    description?: string;
+}
+/** Structured decision produced only by a successful DelegateWork tool call. */
+export interface PetWorkDelegation {
+    workspaceId: string;
+    objective: string;
+    /** Omitted/CodeShell keeps the normal Work Session executor. */
+    executionBackend?: PetWorkExecutionBackend;
+    /** Opaque id from the host-provided reusable Session set; absent means create. */
+    reusableSessionId?: string;
+}
+export interface PetWorkDelegationDecision {
+    ok: boolean;
+    error?: string;
+}

package/dist/delegation.js

@@ -0,0 +1,6 @@
+export const DELEGATE_WORK_TOOL_NAME = "DelegateWork";
+/** Closed set of execution backends; extend here and every schema/validation follows. */
+export const PET_WORK_EXECUTION_BACKENDS = ["codeshell", "codex"];
+export function isPetWorkExecutionBackend(value) {
+    return PET_WORK_EXECUTION_BACKENDS.includes(value);
+}

package/dist/disclosure/catalog.d.ts

@@ -0,0 +1,22 @@
+export interface DiskWorkSession {
+    sessionId: string;
+    title: string;
+    cwd: string | null;
+    status?: string;
+    updatedAt: number;
+}
+export declare function listWorkSessionsOnDisk(sessionsRootDir: string, options: {
+    limit: number;
+}): Promise<DiskWorkSession[]>;
+/**
+ * Resolve one exact ordinary Work Session through the same policy as L1 list.
+ * Keeping this check at the read boundary prevents callers that learned an
+ * internal id elsewhere from bypassing Pet/sub-agent/child/ephemeral filters.
+ */
+export declare function readWorkSessionOnDisk(sessionsRootDir: string, sessionId: string): Promise<DiskWorkSession | null>;
+/**
+ * Resolve one opaque host-issued selector without loading and sorting every
+ * Session state. Directory names are the only candidates hashed; the ordinary
+ * Work Session policy is applied by the exact reader after a match.
+ */
+export declare function readWorkSessionBySelectorOnDisk(sessionsRootDir: string, selectorId: string): Promise<DiskWorkSession | null>;