weaver-work-cli 0.1.32 → 0.1.33

package/dist/chunks/{workflow-DJ7SYWAF.js → workflow-HLBZRWIY.js}

@@ -2,15 +2,22 @@ import { createRequire as __esbuildCreateRequire } from 'node:module';
 const require = __esbuildCreateRequire(import.meta.url);
 import {
   createWorkflowHost
-} from "./chunk-WSKBSQ2U.js";
+} from "./chunk-PRHJGPMA.js";
 import {
+  USER_INTENT_RULE_FILE,
+  aigroupUserDir,
   asObject,
   assertNoForbiddenKeys,
   compactStdoutPaths,
+  emptyRuleFile,
   getWorkflowOperation,
+  loadRuleFile,
+  loadRules,
+  resetActiveRules,
+  validateRuleFile,
   workflowOperationDefinitions,
   workflowSuccess
-} from "./chunk-WKI2FBIQ.js";
+} from "./chunk-OCU4RLHC.js";
 import {
   createWorkflowContinuationSigner
 } from "./chunk-EZALDOQH.js";
@@ -21,8 +28,8 @@ import {
 } from "./chunk-FMPJJYYI.js";
 import "./chunk-EG6ZU444.js";
 import "./chunk-AJ62BGAW.js";
-import "./chunk-DW6AUUKS.js";
-import "./chunk-2GA5ZIQL.js";
+import "./chunk-6ATGWRZM.js";
+import "./chunk-D223PTXU.js";
 import {
   isCliError,
   toErrorEnvelope
@@ -129,6 +136,86 @@ async function executeWorkflowOperation(operation, rawInput, context) {
   return result;
 }
 
+// src/shortcuts/workflow/index.ts
+import { join as join2 } from "node:path";
+
+// src/shortcuts/workflow/operations/todoSmartConvert/aigroupStore.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+function normalizeIntentPayload(payload) {
+  if (Array.isArray(payload)) return payload;
+  if (payload && typeof payload === "object") {
+    const record = payload;
+    if (Array.isArray(record.rules)) return record.rules;
+    if (record.workflowName !== void 0) return [record];
+  }
+  throw workflowValidationError("aigroup_invalid", "\u5165\u53C2\u5FC5\u987B\u662F\u89C4\u5219\u5BF9\u8C61\u3001\u89C4\u5219\u6570\u7EC4\uFF0C\u6216 { rules: [...] }");
+}
+function namesOf(rule) {
+  const raw = rule?.workflowName;
+  if (typeof raw === "string") return [raw.trim()].filter(Boolean);
+  if (Array.isArray(raw)) return raw.map((item) => String(item ?? "").trim()).filter(Boolean);
+  return [];
+}
+function saveUserIntents(payload, options = {}) {
+  const dir = options.dir ?? aigroupUserDir(options.ctx);
+  const warnings = [];
+  const entries = normalizeIntentPayload(payload);
+  if (entries.length === 0) throw workflowValidationError("aigroup_invalid", "\u5165\u53C2\u91CC\u6CA1\u6709\u89C4\u5219\u6761\u76EE");
+  const starred = entries.filter((rule) => namesOf(rule).includes("*"));
+  if (starred.length > 0) {
+    throw workflowValidationError(
+      "aigroup_wildcard_unsupported",
+      "\u7528\u6237\u610F\u56FE\u4E0D\u80FD\u4F7F\u7528\u901A\u914D workflowName\u300C*\u300D\uFF1A\u515C\u5E95\u89C4\u5219\u7531 aigroup/default.json \u51B3\u5B9A"
+    );
+  }
+  const check = validateRuleFile({ schemaVersion: 2, defaults: {}, rules: entries });
+  if (check.length > 0) {
+    throw workflowValidationError("aigroup_invalid", `\u89C4\u5219\u6821\u9A8C\u5931\u8D25\uFF1A${check.join("\uFF1B")}`);
+  }
+  const file = join(dir, USER_INTENT_RULE_FILE);
+  const existing = existsSync(file) ? loadRuleFile(file) : emptyRuleFile();
+  if (existing.error) {
+    warnings.push(`${existing.error}\uFF1B\u672C\u6B21\u5C06\u91CD\u5EFA\u8BE5\u6587\u4EF6`);
+  }
+  const byName = /* @__PURE__ */ new Map();
+  const replaced = [];
+  for (const rule of existing.file.rules) {
+    for (const name of namesOf(rule)) byName.set(name, rule);
+  }
+  for (const rule of entries) {
+    const names = namesOf(rule);
+    for (const name of names) {
+      if (byName.has(name)) replaced.push(name);
+      byName.set(name, rule);
+    }
+  }
+  const merged = [...new Set(byName.values())];
+  const text = `${JSON.stringify({ schemaVersion: 2, rules: merged }, null, 2)}
+`;
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  writeFileSync(file, text, { mode: 384 });
+  return { file, saved: entries.length, total: merged.length, replaced: [...new Set(replaced)], warnings };
+}
+function readUserIntents(options = {}) {
+  const dir = options.dir ?? aigroupUserDir(options.ctx);
+  const file = join(dir, USER_INTENT_RULE_FILE);
+  if (!existsSync(file)) return { dir, file, exists: false, error: null, rules: [] };
+  const loaded = loadRuleFile(file);
+  return { dir, file, exists: true, error: loaded.error, rules: loaded.file.rules };
+}
+function clearUserIntents(options = {}) {
+  const dir = options.dir ?? aigroupUserDir(options.ctx);
+  const file = join(dir, USER_INTENT_RULE_FILE);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  writeFileSync(file, `${JSON.stringify({ schemaVersion: 2, rules: [] }, null, 2)}
+`, { mode: 384 });
+  return file;
+}
+function readRawUserIntents(file) {
+  return readFileSync(file, "utf8");
+}
+
 // src/shortcuts/workflow/index.ts
 function asOptions(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -218,6 +305,43 @@ async function executeAndPrint(ctx, operation, input) {
     process.exitCode = isCliError(error) ? error.exitCode : 1 /* GeneralError */;
   }
 }
+function fieldNamesOf(inputSchema) {
+  const properties = inputSchema.properties;
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) return [];
+  return Object.keys(properties);
+}
+function manifestIndex() {
+  return {
+    schemaVersion: workflowManifest.schemaVersion,
+    name: workflowManifest.name,
+    title: workflowManifest.title,
+    version: workflowManifest.version,
+    host: workflowManifest.host,
+    status: workflowManifest.status,
+    sourceSkill: workflowManifest.sourceSkill,
+    capabilities: workflowManifest.capabilities,
+    operationCount: workflowManifest.operations.length,
+    operations: workflowManifest.operations.map((definition) => ({
+      name: definition.name,
+      resource: definition.resource,
+      summary: definition.summary,
+      ...definition.capability ? { capability: definition.capability } : {},
+      risk: definition.risk,
+      ...definition.requiresConfirmation ? { requiresConfirmation: true } : {},
+      fields: fieldNamesOf(definition.inputSchema)
+    })),
+    withheldOperations: workflowManifest.withheldOperations,
+    operationsHint: "\u9ED8\u8BA4\u53EA\u5217 operation \u4E0E\u5B57\u6BB5\u540D\uFF1B\u5B57\u6BB5\u7C7B\u578B\u3001\u679A\u4E3E\u548C\u586B\u5199\u53E3\u5F84\u7528 `workflow schema --operation <name>` \u5355\u53D6\uFF0C\u6574\u4EFD\u5B8C\u6574 manifest \u7528 `workflow schema --full`\u3002"
+  };
+}
+function findOperationContract(name) {
+  const full = name.startsWith("workflow.") ? name : `workflow.${name}`;
+  const matched = workflowManifest.operations.find((definition) => definition.name === full);
+  if (!matched) {
+    throw workflowValidationError("operation_unknown", `\u6D41\u7A0B\u6A21\u5757\u4E0D\u652F\u6301\u64CD\u4F5C\uFF1A${name}`);
+  }
+  return matched;
+}
 function withJsonInputOptions(command) {
   command.option("--input <path>", "JSON input file, or - for stdin").option("--input-json <json>", "inline JSON input object");
   return command;
@@ -228,8 +352,50 @@ var workflowShortcut = {
   category: "shortcut",
   register({ program, action }) {
     const workflow = program.command("workflow").description("\u6CDB\u5FAEE10\u6D41\u7A0B\u667A\u80FD\u52A9\u624B\uFF08\u5F85\u529E/\u5DF2\u529E/\u6211\u53D1\u8D77/\u5168\u90E8\u3001\u8BE6\u60C5\u3001\u64CD\u4F5C\u3001\u6279\u91CF\u3001\u53D1\u8D77\u3001\u4FEE\u6539\uFF09");
-    workflow.command("schema").description("Print workflow operation manifest for agents").action(action((ctx) => {
-      ctx.output.write(workflowManifest, { json: true });
+    workflow.command("schema").description("Print workflow operation manifest for agents").option("--operation <name>", "print one operation with its full inputSchema").option("--full", "print the whole manifest (about 65 KB; stdout may be trimmed)").action(action((ctx, options) => {
+      const opts = asOptions(options);
+      const requested = String(opts.operation ?? "").trim();
+      if (requested && opts.full === true) {
+        throw workflowValidationError("option_conflict", "\u4E0D\u80FD\u540C\u65F6\u4F20 --operation \u548C --full");
+      }
+      if (opts.full === true) {
+        ctx.output.write(workflowManifest, { json: true });
+        return;
+      }
+      if (requested) {
+        ctx.output.write(findOperationContract(requested), { json: true });
+        return;
+      }
+      ctx.output.write(manifestIndex(), { json: true });
+    }));
+    const aigroup = workflow.command("aigroup").description("ai\u4E8C\u6B21\u5206\u7EC4\u89C4\u5219\u5E93\uFF08\u9ED8\u8BA4\u89C4\u5219 + \u7528\u6237\u610F\u56FE\uFF09");
+    aigroup.command("show").description("Print effective ai-group rules (default merged with user intents)").option("--raw", "also print user-intents.json as stored on disk").action(action((ctx, options) => {
+      const opts = asOptions(options);
+      const loaded = loadRules({ ctx });
+      const user = readUserIntents({ ctx });
+      ctx.output.write({
+        dir: loaded.dir,
+        defaultFile: join2(loaded.dir, "default.json"),
+        userIntentFile: user.file,
+        userIntentExists: user.exists,
+        userIntentError: user.error,
+        defaults: loaded.file.defaults,
+        rules: loaded.file.rules,
+        userRules: user.rules,
+        warnings: loaded.warnings,
+        ...opts.raw === true && user.exists ? { rawUserIntents: readRawUserIntents(user.file) } : {}
+      }, { json: true });
+    }));
+    withJsonInputOptions(aigroup.command("set").description("Save user-intent rules: validated, whole-entry replace by workflowName").action(action(async (ctx, options) => {
+      const payload = await inputFrom(options);
+      const result = saveUserIntents(payload, { ctx });
+      resetActiveRules();
+      ctx.output.write(result, { json: true });
+    })));
+    aigroup.command("clear").description("Empty user-intent rules (default.json is never touched)").action(action((ctx) => {
+      const file = clearUserIntents({ ctx });
+      resetActiveRules();
+      ctx.output.write({ cleared: true, file }, { json: true });
     }));
     withJsonInputOptions(workflow.command("run").description("Run a workflow operation with JSON input").argument("<operation>", "operation name, e.g. workflow.search")).action(action(async (ctx, operation, options) => {
       await executeAndPrint(ctx, String(operation), await inputFrom(options));

package/dist/index.js

@@ -7,12 +7,12 @@ import {
   firstPositionalToken,
   registerCommands,
   toCommandMetadata
-} from "./chunks/chunk-6RKD4DRZ.js";
+} from "./chunks/chunk-GFPXQIY2.js";
 import "./chunks/chunk-EG6ZU444.js";
 import "./chunks/chunk-AJ62BGAW.js";
-import "./chunks/chunk-H7J4DC5R.js";
-import "./chunks/chunk-DW6AUUKS.js";
-import "./chunks/chunk-2GA5ZIQL.js";
+import "./chunks/chunk-EEWPQE3O.js";
+import "./chunks/chunk-6ATGWRZM.js";
+import "./chunks/chunk-D223PTXU.js";
 import "./chunks/chunk-LUSPKZKY.js";
 import "./chunks/chunk-BUSC6UAE.js";
 
@@ -29,7 +29,7 @@ function lazyShortcut(definition) {
       placeholder.allowExcessArguments(true);
       placeholder.helpOption(false);
       placeholder.action(async () => {
-        const { dispatchLazyShortcut } = await import("./chunks/lazy-dispatch-JQXBW3GM.js");
+        const { dispatchLazyShortcut } = await import("./chunks/lazy-dispatch-RNS4EE4S.js");
         await dispatchLazyShortcut(definition, shortcutMetadata());
       });
     }
@@ -39,102 +39,107 @@ var builtinShortcuts = [
   lazyShortcut({
     name: "invoice",
     description: "E10 \u4E1A\u7968\u901A\u53D1\u7968\u7BA1\u7406 CLI",
-    load: async () => (await import("./chunks/invoice-ZK3WCX2U.js")).invoiceShortcut
+    load: async () => (await import("./chunks/invoice-AOXWJKYT.js")).invoiceShortcut
   }),
   lazyShortcut({
     name: "ehr",
     description: "\u6CDB\u5FAEE10\u805A\u624D\u6797\uFF08\u4EBA\u4E8B/\u51FA\u52E4/\u85AA\u916C\uFF09CLI",
-    load: async () => (await import("./chunks/ehr-HMFY6VIL.js")).ehrShortcut
+    load: async () => (await import("./chunks/ehr-WFOC3B4D.js")).ehrShortcut
+  }),
+  lazyShortcut({
+    name: "cowork",
+    description: "\u6CDB\u5FAEE10\u534F\u4F5C\u533A\uFF08\u534F\u4F5C\u4E8B\u9879/\u8BA8\u8BBA/\u5BA1\u6279/\u5171\u4EAB\u6743\u9650\uFF09CLI",
+    load: async () => (await import("./chunks/cowork-CKWYHXYB.js")).coworkShortcut
   }),
   lazyShortcut({
     name: "archive",
     description: "E10 \u6587\u4E66\u5B9A\u6863\u6848\u7BA1\u7406 CLI",
-    load: async () => (await import("./chunks/archive-UMGX72K6.js")).archiveShortcut
+    load: async () => (await import("./chunks/archive-FVFY6GZN.js")).archiveShortcut
   }),
   lazyShortcut({
     name: "archive-oa",
     description: "E10 \u6863\u6848\u5B9A\u4F4D\u4E0E OA \u5546\u52A1\u5408\u540C\u501F\u9605 CLI",
-    load: async () => (await import("./chunks/archive-oa-N2IYBLF3.js")).archiveOaShortcut
+    load: async () => (await import("./chunks/archive-oa-NW3OD4UV.js")).archiveOaShortcut
   }),
   lazyShortcut({
     name: "calendar",
     description: "\u6CDB\u5FAEE10\u65E5\u7A0B\u7BA1\u7406 CLI\uFF08\u521B\u5EFA/\u67E5\u8BE2/\u66F4\u65B0/\u5220\u9664/\u5B57\u5178\uFF09",
-    load: async () => (await import("./chunks/calendar-JKPIRKFD.js")).calendarShortcut
+    load: async () => (await import("./chunks/calendar-7KXE4ED3.js")).calendarShortcut
   }),
   lazyShortcut({
     name: "fna",
     description: "\u6CDB\u5FAEE10\u9F50\u4E1A\u6210\u8D39\u63A7\u4E2D\u5FC3\uFF08\u9884\u7B97/\u8D39\u7528\u4E2D\u5FC3/\u501F\u6B3E\u7BA1\u7406/\u53D1\u7968\u6838\u9500\uFF09CLI",
-    load: async () => (await import("./chunks/fna-B7RKPAZD.js")).fnaShortcut
+    load: async () => (await import("./chunks/fna-F7QRIIZC.js")).fnaShortcut
   }),
   lazyShortcut({
     name: "hrm",
     description: "\u6CDB\u5FAEE10\u7EC4\u7EC7\u7BA1\u7406\uFF08\u5458\u5DE5/\u7EC4\u7EC7/\u5C97\u4F4D\u67E5\u8BE2\uFF09CLI",
-    load: async () => (await import("./chunks/hrm-2KAZGUHI.js")).hrmShortcut
+    load: async () => (await import("./chunks/hrm-NI6XAKW5.js")).hrmShortcut
   }),
   lazyShortcut({
     name: "mail",
     description: "\u6CDB\u5FAEE10\u90AE\u4EF6\u7BA1\u7406 CLI",
-    load: async () => (await import("./chunks/mail-S2HDDXO2.js")).mailShortcut
+    load: async () => (await import("./chunks/mail-VDHJAB4O.js")).mailShortcut
   }),
   lazyShortcut({
     name: "meeting",
     description: "\u6CDB\u5FAEE10\u4F1A\u8BAE\u7BA1\u7406 CLI\uFF08\u6807\u51C6\u7248\uFF1A\u67E5\u8BE2/\u51B2\u7A81/\u9884\u7EA6/\u56DE\u6267/\u7B7E\u5230\uFF09",
-    load: async () => (await import("./chunks/meeting-QVN3I37L.js")).meetingShortcut
+    load: async () => (await import("./chunks/meeting-GA7XCNNP.js")).meetingShortcut
   }),
   lazyShortcut({
     name: "okr",
     description: "\u6CDB\u5FAEE10 OKR \u76EE\u6807\u7BA1\u7406 CLI\uFF08\u76EE\u6807\u67E5\u8BE2/\u65B0\u5EFA/\u7F16\u8F91\u3001\u5173\u952E\u6210\u679C\u3001\u76EE\u6807\u5BF9\u9F50\u3001\u8BC4\u8BBA\uFF09",
-    load: async () => (await import("./chunks/okr-QNG4VC2Q.js")).okrShortcut
+    load: async () => (await import("./chunks/okr-TQIRERPQ.js")).okrShortcut
   }),
   lazyShortcut({
     name: "plan",
     description: "\u6CDB\u5FAEE10\u8BA1\u5212\u62A5\u544A CLI\uFF08\u67E5\u8BE2/\u65B0\u5EFA/\u4FEE\u6539/\u53D1\u5E03/\u64A4\u56DE/\u63D0\u4EA4\u63D0\u9192/\u8BC4\u8BBA\uFF09",
-    load: async () => (await import("./chunks/plan-A25EMW6U.js")).planShortcut
+    load: async () => (await import("./chunks/plan-4RY4LN2P.js")).planShortcut
   }),
   lazyShortcut({
     name: "esb",
     description: "\u6CDB\u5FAEE10 ESB \u4E2D\u5FC3\u81EA\u5B9A\u4E49\u89E6\u53D1\u52A8\u4F5C\u6D41 CLI",
-    load: async () => (await import("./chunks/esb-ZYSVB7SG.js")).esbShortcut
+    load: async () => (await import("./chunks/esb-LJZTN663.js")).esbShortcut
   }),
   lazyShortcut({
     name: "ebuilder-form",
     description: "\u6CDB\u5FAEE10 eBuilder \u8868\u5355\u83DC\u5355\u3001\u5217\u8868\u548C\u8868\u5355\u6570\u636E CLI",
-    load: async () => (await import("./chunks/ebuilder-form-V5FG2EHC.js")).ebuilderFormShortcut
+    load: async () => (await import("./chunks/ebuilder-form-KOLJRVZD.js")).ebuilderFormShortcut
   }),
   lazyShortcut({
     name: "jiuchuanhui",
     description: "\u6CDB\u5FAEE10\u4E5D\u6C1A\u6C47\u8425\u9500\u7BA1\u7406 CLI\uFF08\u5BA2\u6237/\u8054\u7CFB\u4EBA/\u5546\u673A/\u7EBF\u7D22/\u8054\u7CFB\u8BA1\u5212/\u516C\u6D77\uFF09",
-    load: async () => (await import("./chunks/jiuchuanhui-5PQD3IL2.js")).jiuchuanhuiShortcut
+    load: async () => (await import("./chunks/jiuchuanhui-7NQWEZAW.js")).jiuchuanhuiShortcut
   }),
   lazyShortcut({
     name: "asset",
     description: "E10 \u8D44\u4EA7\u7BA1\u7406\uFF08\u8D44\u7BA1\u5BB6\uFF09CLI",
-    load: async () => (await import("./chunks/asset-GLEGKFG5.js")).assetShortcut
+    load: async () => (await import("./chunks/asset-7QJKMIDV.js")).assetShortcut
   }),
   lazyShortcut({
     name: "im",
     description: "\u6CDB\u5FAEE10\u6613\u79D2\u529E\uFF08\u5373\u65F6\u901A\u8BAF\uFF09CLI",
-    load: async () => (await import("./chunks/im-ACJJWH4U.js")).imShortcut
+    load: async () => (await import("./chunks/im-7TRTF3KT.js")).imShortcut
   }),
   lazyShortcut({
     name: "project",
     description: "\u6CDB\u5FAEE10\u4E8B\u4E95\u7136\u9879\u76EE\u7BA1\u7406 CLI\uFF08\u9879\u76EE/\u4EFB\u52A1\u67E5\u8BE2\u4E0E\u786E\u8BA4\u5199\u5165\uFF09",
-    load: async () => (await import("./chunks/project-G6XV66DZ.js")).projectShortcut
+    load: async () => (await import("./chunks/project-D6XT2OC5.js")).projectShortcut
   }),
   lazyShortcut({
     name: "workflow",
     description: "\u6CDB\u5FAEE10\u6D41\u7A0B\u667A\u80FD\u52A9\u624B CLI\uFF08\u67E5\u8BE2/\u67E5\u770B/\u64CD\u4F5C/\u6279\u91CF/\u53D1\u8D77/\u4FEE\u6539\uFF09",
-    load: async () => (await import("./chunks/workflow-DJ7SYWAF.js")).workflowShortcut
+    load: async () => (await import("./chunks/workflow-HLBZRWIY.js")).workflowShortcut
   }),
   lazyShortcut({
     name: "blog",
     description: "\u6CDB\u5FAEE10\u5DE5\u4F5C\u65E5\u62A5 CLI\uFF08\u67E5\u8BE2/\u53D1\u5E03/\u7F16\u8F91/\u8BC4\u8BBA/\u70B9\u8D5E/\u63D0\u9192/\u5BFC\u51FA\uFF09",
-    load: async () => (await import("./chunks/blog-E44OTVDA.js")).blogShortcut
+    load: async () => (await import("./chunks/blog-I7SDPNW4.js")).blogShortcut
   }),
   lazyShortcut({
     name: "caizhilian",
     description: "\u6CDB\u5FAEE10\u91C7\u77E5\u8FDE\uFF08\u6587\u6863\u4E2D\u5FC3\uFF09CLI",
-    load: async () => (await import("./chunks/caizhilian-DQUFZXZL.js")).caizhilianShortcut
+    load: async () => (await import("./chunks/caizhilian-O37ZIQNY.js")).caizhilianShortcut
   })
 ];
 function shortcutMetadata() {

package/dist/internal/e10/auth-recovery.js

@@ -1,3 +1,4 @@
+import { isXiaoERuntimeAgent } from '../../core/runtime-agent.js';
 import { getActiveProfile } from './auth/session.js';
 import { hasXiaoEEnv, tryXiaoEUnifiedLogin } from './auth/xiaoe.js';
 const AUTH_REQUIRED_CODES = new Set(['-2', '401']);
@@ -94,12 +95,21 @@ export function isE10AuthenticationRequired(response) {
 function globalOptions(ctx) {
     return typeof ctx.getGlobalOptions === 'function' ? ctx.getGlobalOptions() : {};
 }
-/** XiaoE automatic recovery is opt-in through explicit runtime evidence. */
-export function canAutomaticallyRecoverXiaoE(ctx) {
+/**
+ * Decide whether an expired session can be recovered through XiaoE without
+ * involving the caller/Agent. Runtime evidence is preferred, but a persisted
+ * XiaoE login is also authoritative: business commands often run in a fresh
+ * process where the host no longer injects its original XIAOE_* markers.
+ */
+export function canAutomaticallyRecoverXiaoE(ctx, currentSession) {
     const options = globalOptions(ctx);
     // An explicitly supplied auth file is caller-owned and must not be replaced
     // by a profile-backed XiaoE session behind the caller's back.
-    return !options.auth && hasXiaoEEnv(ctx.env || process.env, options);
+    if (options.auth)
+        return false;
+    return hasXiaoEEnv(ctx.env || process.env, options)
+        || currentSession?.loginSource === 'xiaoe-unified'
+        || isXiaoERuntimeAgent(currentSession?.agentType);
 }
 /**
  * Silently refresh a stale XiaoE session. Concurrent requests for the same
@@ -107,7 +117,7 @@ export function canAutomaticallyRecoverXiaoE(ctx) {
  * does not start a burst of login attempts.
  */
 export async function recoverXiaoEAuthSession(ctx, currentSession) {
-    if (!canAutomaticallyRecoverXiaoE(ctx))
+    if (!canAutomaticallyRecoverXiaoE(ctx, currentSession))
         return null;
     const options = globalOptions(ctx);
     const profile = options.profile || getActiveProfile();

package/dist/shortcuts/contract/host.js

@@ -3,6 +3,7 @@ import { basename } from 'node:path';
 import { E10_SESSION_EXPIRED_MESSAGE } from '../../internal/e10/auth/messages.js';
 import { requireE10Session } from '../../internal/e10/context.js';
 import { getActiveProfile } from '../../internal/e10/auth/session.js';
+import { E10ApiError, createE10RequestRuntime, } from '../../internal/e10/request-runtime.js';
 import { ContractCliError, contractAuthError, contractNetworkError, contractValidationError, } from './errors.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
 function assertPath(requestPath) {
@@ -16,38 +17,6 @@ function assertPath(requestPath) {
         throw contractValidationError('path_not_allowed', '今承达合同管理只能调用 /api/ 路径');
     }
 }
-function withQuery(baseUrl, requestPath, query = {}) {
-    const url = new URL(`${baseUrl}${requestPath}`);
-    for (const [key, value] of Object.entries(query)) {
-        if (value === undefined || value === null || value === '')
-            continue;
-        if (Array.isArray(value)) {
-            for (const item of value)
-                url.searchParams.append(key, String(item));
-        }
-        else {
-            url.searchParams.set(key, String(value));
-        }
-    }
-    return url;
-}
-async function fetchWithTimeout(url, options, timeoutMs) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        return await fetch(url, { ...options, signal: controller.signal, redirect: 'manual' });
-    }
-    catch (error) {
-        if (error instanceof Error && error.name === 'AbortError') {
-            throw contractNetworkError('timeout', `请求超时（${timeoutMs}ms）`, { retryable: false });
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        throw contractNetworkError('transport', `请求失败：${message}`, { retryable: true });
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
 function textOf(value, keys) {
     for (const key of keys) {
         const candidate = value?.[key];
@@ -131,15 +100,6 @@ function inferProfile(ctx) {
     const options = ctx.getGlobalOptions();
     return options.profile || getActiveProfile();
 }
-function requestHeaders(session) {
-    return {
-        Accept: 'application/json, text/plain, */*',
-        Cookie: session.cookieHeader(),
-        eteamsid: session.eteamsId,
-        'User-Agent': session.uaHeader(),
-        Origin: session.getBaseUrl(),
-    };
-}
 export function createContractHost(ctx, dependencies = {}) {
     let e10Session = null;
     let sessionContext = null;
@@ -164,10 +124,9 @@ export function createContractHost(ctx, dependencies = {}) {
         assertPath(path);
         const session = await ensureSession();
         const context = await getSession();
-        const headers = { ...requestHeaders(session), ...(extraHeaders ?? {}) };
-        const finalQuery = { ...query };
+        const finalQuery = Object.fromEntries(Object.entries(query).filter(([, value]) => value !== undefined && value !== null && value !== ''));
         let finalBody = body;
-        const init = { method, headers };
+        let formData;
         if (userIdField) {
             if (!context.userId) {
                 throw contractAuthError('user_id_missing', '当前会话没有可用的用户 ID，请确认 E10 登录态');
@@ -178,9 +137,9 @@ export function createContractHost(ctx, dependencies = {}) {
                 finalBody = { ...finalBody, [userIdField]: context.userId };
         }
         if (form || file) {
-            const data = new FormData();
+            formData = new FormData();
             for (const [key, value] of Object.entries(form ?? {}))
-                data.append(key, value);
+                formData.append(key, value);
             if (file) {
                 let buffer;
                 try {
@@ -190,25 +149,41 @@ export function createContractHost(ctx, dependencies = {}) {
                     throw contractValidationError('file_unreadable', `无法读取文件：${file.path}`);
                 }
                 const filename = file.filename ?? basename(file.path);
-                data.append(file.field ?? 'file', new Blob([new Uint8Array(buffer)], { type: file.contentType ?? 'application/octet-stream' }), filename);
+                formData.append(file.field ?? 'file', new Blob([new Uint8Array(buffer)], { type: file.contentType ?? 'application/octet-stream' }), filename);
             }
-            init.body = data;
         }
-        else if (finalBody !== undefined) {
-            headers['Content-Type'] = 'application/json;charset=UTF-8';
-            init.body = JSON.stringify(finalBody);
+        const runtime = createE10RequestRuntime(ctx, session, {
+            interceptors: dependencies.interceptors,
+            fetch: dependencies.fetch,
+            recoverAuthentication: dependencies.recoverAuthentication,
+        });
+        let response;
+        try {
+            response = await runtime.requestJson({
+                module: 'contract',
+                method,
+                path,
+                query: finalQuery,
+                body: formData ? undefined : finalBody,
+                formData,
+                headers: extraHeaders,
+                timeoutMs,
+            });
+        }
+        catch (error) {
+            if (error instanceof E10ApiError && error.type === 'network') {
+                throw contractNetworkError(error.subtype, error.message, {
+                    retryable: error.retryable,
+                    details: error.details,
+                });
+            }
+            throw error;
         }
-        const url = withQuery(context.baseUrl, path, finalQuery);
-        const response = await fetchWithTimeout(url, init, timeoutMs);
         if (response.status === 401 || response.status === 302) {
             throw contractAuthError('session_expired', E10_SESSION_EXPIRED_MESSAGE, { httpStatus: response.status, path });
         }
-        const text = await response.text();
-        let value = {};
-        try {
-            value = text ? JSON.parse(text) : {};
-        }
-        catch {
+        const { text, value } = response;
+        if (response.parseError) {
             throw contractNetworkError('protocol', `接口返回不是合法 JSON（HTTP ${response.status}）`, {
                 retryable: false,
                 details: { path, status: response.status },

package/dist/shortcuts/cowork/continuation.js

@@ -0,0 +1,70 @@
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { coworkValidationError } from './errors.js';
+function stateRoot(ctx) {
+    const configured = ctx?.config?.path();
+    if (configured)
+        return resolve(configured, '..');
+    return process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), '.weaver-work-cli');
+}
+async function loadKey(ctx) {
+    const keysDir = resolve(stateRoot(ctx), 'keys');
+    const filename = resolve(keysDir, 'cowork-continuation.key');
+    await mkdir(keysDir, { recursive: true, mode: 0o700 });
+    if (existsSync(filename))
+        return readFile(filename);
+    const key = randomBytes(32);
+    try {
+        await writeFile(filename, key, { flag: 'wx', mode: 0o600 });
+        if (process.platform !== 'win32')
+            await chmod(filename, 0o600).catch(() => undefined);
+        return key;
+    }
+    catch {
+        return readFile(filename);
+    }
+}
+function encode(value) {
+    return Buffer.from(JSON.stringify(value)).toString('base64url');
+}
+function signature(payload, key) {
+    return createHmac('sha256', key).update(payload).digest('base64url');
+}
+export function createCoworkContinuationSigner(ctx) {
+    return {
+        async issue(payload, ttlMs = 10 * 60_000) {
+            const issuedAt = Date.now();
+            const body = encode({ ...payload, issuedAt, expiresAt: issuedAt + ttlMs });
+            const sig = signature(body, await loadKey(ctx));
+            return `${body}.${sig}`;
+        },
+        async verify(token, expectedOperation) {
+            if (typeof token !== 'string' || !token.includes('.')) {
+                throw coworkValidationError('continuation_invalid', 'continuation 无效');
+            }
+            const [body, provided] = token.split('.');
+            const expected = signature(body, await loadKey(ctx));
+            const valid = provided.length === expected.length
+                && timingSafeEqual(Buffer.from(provided), Buffer.from(expected));
+            if (!valid)
+                throw coworkValidationError('continuation_invalid', 'continuation 签名校验失败');
+            let value;
+            try {
+                value = JSON.parse(Buffer.from(body, 'base64url').toString('utf8'));
+            }
+            catch {
+                throw coworkValidationError('continuation_invalid', 'continuation 内容无法解析');
+            }
+            if (value.operation !== expectedOperation) {
+                throw coworkValidationError('continuation_mismatch', 'continuation 不属于当前操作');
+            }
+            if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt < Date.now()) {
+                throw coworkValidationError('continuation_expired', 'continuation 已过期');
+            }
+            return value;
+        },
+    };
+}