@dipoleml/dcode-cli 1.1.0 → 1.2.1

package/dist/packages/bundled-skills/skills/dynamic-workflows/patterns.md

@@ -7,8 +7,14 @@ define every type it names.
 The snippets here are **fragments, not runnable scripts**: they name types and subagents that
 the surrounding prose leaves to you. Complete scripts live in `examples.md`.
 
-For the API surface itself, read the `CreateWorkflow` tool description. For the reasoning
-behind these choices, read `SKILL.md`.
+**Start with the pipeline shapes.** Most scripts have more than one stage, and the stages
+should work at the same time, each item moving on as soon as it is ready (SKILL.md §7). #10
+chains stages that map one to one inside one fan-out; #11 streams items between stages through
+channels; #12 adds a feedback loop from a later stage to an earlier one. The other shapes are
+the pieces those pipelines are built from.
+
+For the API surface itself, read SKILL.md §16. For the reasoning behind these choices, read
+the rest of `SKILL.md`.
 
 ---
 
@@ -23,6 +29,7 @@ const paths = await files.glob("src/**/*.ts");
 log(`fanning out over ${paths.length} files`);
 
 phase("Security-audit each file independently");
+// The report below needs every verdict, so this join is the right one.
 const verdicts = await Promise.all(
   paths.map((p) =>
     agent(`auditor-${p}`).ask<Verdict>(`Security-review ${p}. Report only real issues.`),
@@ -178,6 +185,7 @@ where correlated judges would defeat the purpose:
 
 ```ts
 phase("Judge the finding from three angles");
+// A majority needs every vote, so the join waits for all three.
 const votes = await Promise.all(
   ["correctness", "security", "does-it-reproduce"].map((lens) =>
     agent(`judge-${lens}`)
@@ -241,9 +249,10 @@ first. Never let the loop fall off the end returning nothing.
 
 ---
 
-## 6. Staged pipeline with typed handoff
+## 6. Staged handoff with typed results
 
-**When:** each stage narrows or transforms what the next one works on.
+**When:** each stage narrows or transforms what the next one works on, and the last stage
+needs everything the one before it produced.
 
 ```ts
 phase("Survey which modules touch auth");
@@ -251,6 +260,7 @@ const survey = await agent("surveyor").ask<Survey>("List the modules that touch
 log(`${survey.modules.length} modules in scope`);
 
 phase("Analyse each module for auth bypasses");
+// The write-up deduplicates across modules, so it needs every analysis at once.
 const analyses = await Promise.all(
   survey.modules.map((m) =>
     agent(`analyst-${m.path}`).ask<Analysis>(
@@ -458,3 +468,325 @@ re-entering two markers out of order would stamp each other's steps.
 When one item failing should cost one item, catch inside the callback (examples #3) or use
 `Promise.allSettled` and read each outcome; a rejection inside a plain `Promise.all` rejects
 the join and the siblings with it.
+
+## 11. Streaming pipeline with channels
+
+**When:** items should flow to the next stage as they are produced, and the shape is one
+chaining (#10) cannot write: a pool of K shared workers serving a stage, a producer still
+finding items while consumers work, a later stage sending work back (#12), or stages you want
+to read as separate blocks. Each stage is a
+`future` whose body opens with its own phase marker; a `channel` carries items between two
+stages; the producing stage owns the `close()` in a `finally`.
+
+```ts
+const leads = channel<Lead>("leads");
+const facts = channel<Fact>("facts");
+const checked: Checked[] = [];
+
+const seed = future(async () => {
+  phase("Decide what to look into");
+  try {
+    const plan = await agent("planner").ask<{ questions: string[] }>(`List the questions to answer about ${topic}.`);
+    for (const question of plan.questions) leads.send({ question });
+  } finally {
+    leads.close();
+  }
+});
+
+const research = future(async () => {
+  phase("Research each question");
+  try {
+    await Promise.all(
+      Array.from({ length: RESEARCHERS }, async (_, k) => {
+        // One context per worker, hoisted out of the loop: a name is minted once per worker,
+        // and what one worker learnt on an earlier question is there for its next.
+        const researcher = agent(`researcher-${k + 1}`);
+        for await (const lead of leads) {
+          const found = await researcher.ask<Research>(`Research: ${lead.question}`);
+          found.facts.forEach((fact, index) => facts.send({ ...fact, id: `${lead.question}-${index + 1}` }));
+        }
+      }),
+    );
+  } finally {
+    facts.close(); // a failed researcher still ends the stream for the verifiers
+  }
+});
+
+const verify = future(async () => {
+  phase("Check each fact as it arrives");
+  await Promise.all(
+    Array.from({ length: VERIFIERS }, async (_, k) => {
+      const verifier = agent(`verifier-${k + 1}`);
+      for await (const fact of facts) {
+        const verdict = await verifier.ask<Verdict>(`Check: ${JSON.stringify(fact)}`);
+        checked.push({ ...fact, ...verdict });
+        report({ ...fact, ...verdict });
+      }
+    }),
+  );
+});
+
+// Start every stage first, then join all of them once. No await between the two: while the
+// script awaits one stage, a failure in another has no listener and surfaces as an unhandled
+// rejection instead of failing the run with its error.
+await Promise.all([seed, research, verify]);
+
+phase("Write the report from the checked facts");
+const summary = await agent("writer").ask<string>(`Write up:\n${JSON.stringify(checked)}`);
+```
+
+Three stages, three markers, one join. The writer comes after the join, not on a channel: it
+needs every checked fact, so a shared array and the join is the right hand-off there. A
+channel where the next stage should start early; a join where it cannot.
+
+The pools here (`researcher-1…3`, `verifier-1…4`) share a context across the items each
+worker happens to receive, which is what you want when the items must be judged on one scale
+or when what was learnt on one item helps with the next. The price is cache locality on a
+revised run: which item lands on which worker depends on timing, so an amendment that changes
+one upstream item shifts the assignment and misses the cache for the whole pool. When the items
+are independent and you expect to amend, spawn a fresh, item-named subagent per item inside the
+`for await` instead — a `future` pushed into an array and joined before the stage ends
+(examples #6).
+
+## 12. Feedback loop with a counted close
+
+**When:** a later stage sends work back to an earlier one — a verifier that doubts a fact asks
+for more research on it. The feedback channel has no single producer who knows when it is
+done, so the script counts open work items and closes the channel when the count hits zero. A
+depth field on each item bounds the loop.
+
+```ts
+const leads = channel<Lead>("leads");
+const facts = channel<Fact>("facts");
+// Open work items: every lead sent and not yet researched, every fact sent and not yet judged.
+// The feedback channel closes when this reaches zero, and nobody else may close it.
+let open = 0;
+function finished(): void {
+  open -= 1;
+  if (open === 0) leads.close();
+}
+
+for (const question of seeds) {
+  open += 1;
+  leads.send({ question, depth: 0 });
+}
+
+const research = future(async () => {
+  phase("Research each lead");
+  try {
+    await Promise.all(
+      Array.from({ length: WORKERS }, async (_, k) => {
+        const researcher = agent(`researcher-${k + 1}`);
+        for await (const lead of leads) {
+          const found = await researcher.ask<Research>(`Research: ${lead.question}`);
+          // Invariant 1: count every child BEFORE finishing the parent, so `open` never
+          // touches zero while work is still being produced.
+          found.facts.forEach((fact, index) => {
+            open += 1;
+            facts.send({ ...fact, id: `${lead.question}-${index + 1}`, depth: lead.depth });
+          });
+          finished();
+        }
+      }),
+    );
+  } finally {
+    // Invariant 2: a researcher sends facts only from inside its loop, so this close runs after
+    // the last researcher has left the loop and nothing can send to `facts` any more.
+    facts.close();
+  }
+});
+
+const verify = future(async () => {
+  phase("Check each fact, and send doubts back for more research");
+  const checks: Promise<void>[] = [];
+  for await (const fact of facts) {
+    checks.push(
+      future(async () => {
+        const verdict = await agent(`verifier-${fact.id}`).ask<Verdict>(`Check: ${JSON.stringify(fact)}`);
+        if (verdict.holds) passed.push(fact);
+        else if (verdict.followUp !== undefined && fact.depth < MAX_DEPTH) {
+          // This fact is still open, so `open` is at least 1 and `leads` cannot have closed:
+          // the follow-up is counted before the fact that produced it is finished.
+          open += 1;
+          leads.send({ question: verdict.followUp, depth: fact.depth + 1 });
+        } else rejected.push(fact.claim);
+        finished();
+      }),
+    );
+  }
+  await Promise.all(checks); // the stage is done when its checks are, not when `facts` closes
+});
+
+await Promise.all([research, verify]);
+```
+
+Why the count closes `leads` and nothing else can: an item is finished only after every item
+it produced has been counted, so `open` reaches zero exactly once, when the last item of the
+last generation has been judged and produced nothing. The researchers then leave their loops,
+the research stage closes `facts`, the verify stage's `for await` ends, and its join settles.
+Forget the increment-before-finish order and `open` can hit zero with a follow-up about to be
+sent — `leads.send` then throws `ChannelClosed`. Forget the join over `checks` and the stage
+ends early with verdicts still running; the deadlock detector cannot see that one, because
+nothing is parked. Forget the depth bound and two subagents can keep each other busy forever.
+
+## 13. Model routing
+
+**When:** the user asked for cheaper or faster models where they are enough, and one subagent
+can tell which requests need the strong model. A router on the light model answers with a
+typed key; code maps the key to a model the script declared. The router never writes a model
+name, so it can only pick among models the user approved in the window.
+
+<!-- compile -->
+```ts
+// Every model the run can use, declared once; names come from ListModels.
+const MODELS = {
+  light: model("Raven Flash"),
+  strong: model("Raven Max$high"),
+};
+
+interface Route {
+  /** "strong" only when the request needs multi-step reasoning or careful writing. */
+  tier: "light" | "strong";
+}
+
+interface Reply {
+  answer: string;
+}
+
+const questions: string[] = ["Rename the config key in the README", "Explain the retry design"];
+
+// Routing and answering map one to one, so each question goes to its answerer the moment
+// its route is decided; the one join is for the return, which needs every answer.
+phase("Route each question to the model it needs and answer it there");
+const replies = await Promise.all(
+  questions.map(async (question, index) => {
+    const route = await agent(`分诊-${index + 1}`, { model: MODELS.light }).ask<Route>(
+      `Would answering this well need the strong model? ${question}`,
+    );
+    return agent(`答复者-${index + 1}`, { model: MODELS[route.tier] }).ask<Reply>(question);
+  }),
+);
+return replies.map((reply) => reply.answer);
+```
+
+A fixed choice needs no table: `agent("评审员", { model: "Raven Flash" })`. Keep the table at
+the top of the script: an amend changes a model in one place, and the finished work of a
+subagent whose model changed is still reused — its next live ask runs on the new model.
+
+---
+
+## 14. Growth by tail holes
+
+**When:** the task is complicated enough that its workflow cannot be planned from the request
+— the next step depends on what the last one found. Write what is known and end the script
+with a tail hole. The script then grows by nesting: each fill is the statements of the
+innermost body, does one step, and ends in the next tail hole; the last fill returns.
+(`SKILL.md` §15; the complete chain with its fill files is `examples.md` #7.)
+
+```ts
+// 0. The seed, submitted with CreateWorkflow.
+phase("盘点仓库顶层目录");
+const survey = await agent("勘察员").ask<Survey>("列出顶层目录，各用一句话说明作用。");
+return await hole<Guide>("第1步：决定导览结构", `盘点：${JSON.stringify(survey.dirs)}`);
+```
+
+```ts
+// 1. The effective script after the first FillWorkflowHole: the hole gained a body
+//    that does one step and leaves the next hole. Only the body's statements were sent.
+return await hole<Guide>("第1步：决定导览结构", `盘点：…`, async () => {
+  phase("分章并行撰写初稿");
+  const drafts = await Promise.all(
+    survey.dirs.map((d) => agent(`写手·${d.path}`).ask<Chapter>(`写「${d.path}」一章：${d.purpose}`)),
+  );
+  return await hole<Guide>("第2步：审读与交付", `${drafts.length} 章初稿已就绪`);
+});
+```
+
+```ts
+// 2. After the second fill: the chain closes with a value. Each hole's site id comes
+//    from its name, so ids stay short at any depth; the timeline shows one head per step.
+return await hole<Guide>("第1步：决定导览结构", `盘点：…`, async () => {
+  /* step 1 as above; `survey` and `drafts` are in scope below */
+  return await hole<Guide>("第2步：审读与交付", `…`, async () => {
+    phase("独立审读并修订");
+    const critique = await agent("审读员").ask<string>(`只凭文本挑毛病：${JSON.stringify(drafts)}`);
+    const chapters = await agent("修订编辑").ask<Chapter[]>(`按意见修订：${critique}\n${JSON.stringify(drafts)}`);
+    return { title: "仓库导览", chapters, notCovered: [] };
+  });
+});
+```
+
+The rules that make a chain work: every hole name is unique across the whole effective
+script, so name each step for what it does (`第N步：…`), never the same name twice; the prompt
+carries the progress the next author needs (counts, titles, what failed), because it is the
+only channel for values; results live in bindings (`survey`, `drafts`), which every inner
+body reads, so nothing needs re-asking; a step may open phases, create subagents, fan out and
+gate with `world.run` like any script. The chain ends when a fill returns instead of leaving
+a hole. A restart resumes the chain where it waited, with the finished steps replayed from
+the journal.
+
+---
+
+## 15. A stage shaped by discovery
+
+**When:** the survey decides the *topology* of the next stage, not just its inputs — how many
+reviewers, fanned out or sequential, which check gates them. The survey's value goes to the
+script as data; the fill writes the stage.
+
+```ts
+phase("剖析热点");
+const hot = await agent("剖析员").ask<Hotspots>("找出最慢的三个模块，说明各自的耦合。");
+const reviews = await hole<Review[]>("怎么审查这些热点", `热点：${JSON.stringify(hot.modules)}`);
+phase("汇总");
+return await agent("汇总员").ask<Report>(`汇总审查结果：${JSON.stringify(reviews)}`);
+```
+
+A fill written once `hot` says two modules are independent and one is shared by both: the
+independent pair reviewed in parallel, the shared one by a calibrated reviewer that has seen
+the other two reviews, then a bounded fix-and-recheck loop gated by the project's own test
+command. None of that topology was knowable before the survey.
+
+```ts
+phase("并行审查独立模块");
+const [a, b] = await Promise.all(
+  hot.modules.slice(0, 2).map((m) => agent(`审查员·${m.path}`).ask<Review>(`审查 ${m.path}：${m.coupling}`)),
+);
+phase("在前两份审查的基础上审查共享模块");
+const shared = hot.modules[2];
+const reviewer = agent("共享模块审查员", "你在别人的审查基础上工作，只找他们没看到的问题。");
+let review = await reviewer.ask<Review>(`已有审查：${JSON.stringify([a, b])}\n现在审查 ${shared.path}`);
+for (let round = 1; round <= 3 && review.findings.length > 0; round += 1) {
+  const fix = await world.run("pnpm", ["test", "--", shared.path]);
+  if (fix.exitCode === 0) break;
+  review = await reviewer.ask<Review>(`测试仍失败：${fix.stderr}\n复审 ${shared.path}`);
+}
+return [a, b, review];
+```
+
+Contrast with a plain subagent ask: had the survey only said *which* modules to review, the
+script could have fanned out over `hot.modules` itself and no hole was needed.
+
+---
+
+## 16. A remedy the plan could not enumerate
+
+**When:** a gate fails and the fix may need phases and subagents nobody planned. If the
+remedies were known — retry, narrow, skip — the script would hold a `Remedy` value and an
+`if`; the hole is for the case where the remedy is a piece of workflow decided with the
+failure in hand.
+
+```ts
+phase("跑完整测试");
+const gate = await world.run("pnpm", ["test"], { timeoutMs: 1_800_000 });
+if (gate.exitCode !== 0) {
+  await hole<void>("测试没过怎么办", `退出码 ${gate.exitCode}：\n${gate.stderr.slice(0, 2000)}`);
+}
+phase("交付");
+return await agent("报告员").ask<Report>("写交付报告。");
+```
+
+A fill after a flaky-looking failure: a bisect over the last commits by `world.run`, a
+second opinion from a fresh subagent on whether the failure is real, and — only if it is —
+a fixer loop bounded by three rounds. A fill after a clear failure is one fixer and one
+recheck. The script did not have to guess which, and the user sees the remedy as phases of
+its own under the hole's head.

package/dist/packages/node-repl-host/.dcode-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "node-repl-host",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Shared node_repl runtime host for DCode official capabilities. Not user-facing: it carries no skill and appears in no marketplace listing; Browser Use and Computer Use enable it and contribute their own skills, docs and runtime assets.",
   "author": { "name": "DipoleML" },
   "license": "MIT"

package/dist/packages/node-repl-host/dist/mcp/server.js

@@ -54199,7 +54199,9 @@ var browserCommandSchema = external_exports.discriminatedUnion("method", [
     deliverable: external_exports.boolean().optional()
   }).strict(),
   external_exports.object({ method: external_exports.literal("turnEnded"), turnId: external_exports.string().min(1).optional() }).strict(),
-  external_exports.object({ method: external_exports.literal("closeSession") }).strict(),
+  // closeTabs：连同该 session 名下的 tab 一起关（含已释放回该 session 的）。只给永不回来认领的
+  // session 用——dwf 子代理（docs/browser-use/2026-07-14-browser-tab-conversation-isolation-spec.md §2.3）。
+  external_exports.object({ method: external_exports.literal("closeSession"), closeTabs: external_exports.boolean().optional() }).strict(),
   external_exports.object({ method: external_exports.literal("cancelRequest"), requestId: external_exports.string().min(1) }).strict(),
   // close：关闭指定受控 tab（tabId 缺省=当前 tab）。manager 层处理：detach + 通知 renderer 卸载 webview。
   external_exports.object({ method: external_exports.literal("close"), tabId: external_exports.string().optional() }).strict(),
@@ -54422,7 +54424,6 @@ var nodeReplBrowserBrokerResponseSchema = external_exports.discriminatedUnion("o
 
 // src/runtime-bridge.ts
 var NODE_REPL_BROWSER_BRIDGE_SYMBOL = Symbol.for("dcode.node-repl.browser-control-bridge");
-var BROWSER_UNAVAILABLE_IN_SUBAGENT_MESSAGE = "Browser is not available in subagent";
 
 // src/browser-bridge.ts
 var MAX_RESPONSE_BYTES = 32 * 1024 * 1024;
@@ -54434,16 +54435,9 @@ function createBrowserBridgeGlobals(input2) {
     }
     return active;
   };
-  const assertAvailable = () => {
-    const active = assertActive();
-    if (active.requestMeta.runtime_scope === "subagent") {
-      throw new Error(BROWSER_UNAVAILABLE_IN_SUBAGENT_MESSAGE);
-    }
-    return active;
-  };
   const transport = {
     list: async () => {
-      const active = assertAvailable();
+      const active = assertActive();
       const response = await sendBrokerRequest(
         { op: "list", ...requestContext(active.requestMeta) },
         active.signal
@@ -54452,7 +54446,7 @@ function createBrowserBridgeGlobals(input2) {
       return response.browsers ?? [];
     },
     execute: async (browserId, browserGeneration, command) => {
-      const active = assertAvailable();
+      const active = assertActive();
       const response = await sendBrokerRequest(
         {
           op: "execute",
@@ -54473,7 +54467,7 @@ function createBrowserBridgeGlobals(input2) {
     [NODE_REPL_BROWSER_BRIDGE_SYMBOL]: {
       ...transport,
       documentationRoot: input2.documentationRoot,
-      assertAvailable
+      assertAvailable: assertActive
     }
   };
 }
@@ -54983,6 +54977,7 @@ async function isDirectMcpEntrypoint(importMetaUrl, argvPath) {
 // ../contracts/dist/interfaces/mcp.port.js
 var DCODE_MCP_BROWSER_SCREENSHOT_CONTENT_INDICES_META_KEY = "dcode/browserScreenshotContentIndices";
 var DCODE_MCP_NODE_REPL_CUA_APP_META_KEY = "dcode/nodeReplCuaApp";
+var MCP_TOOL_META_TIMEOUT_MAX_MS = 30 * 60 * 1e3;
 
 // ../../../../packages/dcode-cua/frame-contract.js
 var OFFICIAL_CUA_IMAGE_INLINE_BASE64_BYTES = 200 * 1024;
@@ -55093,7 +55088,7 @@ function toMcpRunResult(run) {
 
 // src/tool-contract.ts
 var NODE_REPL_DEFAULT_TIMEOUT_MS = 6e4;
-var NODE_REPL_SERVER_VERSION = "0.6.0";
+var NODE_REPL_SERVER_VERSION = "0.6.1";
 var NODE_REPL_SERVER_INSTRUCTIONS = `Browser Use and Computer Use only. Use \`js\` to run JavaScript in a fresh Node-backed kernel only when the corresponding official skill instructs you to control a browser or computer. Do not use this server for unrelated tasks, including general-purpose JavaScript, filesystem, shell, package inspection, or data processing. Calls default to a ${NODE_REPL_DEFAULT_TIMEOUT_MS} ms timeout. Always provide \`title\` as a short user-facing description in the user's language. Every \`js\` call starts fresh; reconstruct browser wrappers and recover persistent tabs from current BrowserControl facts.`;
 var JS_TOOL_DESCRIPTION = `Browser Use and Computer Use only. Run JavaScript in a fresh Node-backed kernel with top-level await only as instructed by the corresponding official skill to control a browser or computer. Do not use it as a general-purpose JavaScript runtime or for filesystem, shell, package inspection, data processing, or other non-browser work. Always provide the required \`title\` as a short user-facing description in the user's language without implementation terms. If \`timeout_ms\` is omitted, execution times out after ${NODE_REPL_DEFAULT_TIMEOUT_MS} ms. If the code may take more than 30000 ms including all awaited operations, you MUST set \`timeout_ms\` to at least the estimated total runtime plus 15000 ms; split the work into multiple calls if that exceeds the 120000 ms maximum. Use \`nodeRepl.cwd\`, \`nodeRepl.homeDir\`, \`nodeRepl.tmpDir\`, \`nodeRepl.requestMeta\`, \`nodeRepl.setResponseMeta(meta)\`, \`nodeRepl.write(value)\`, and \`await nodeRepl.emitImage(imageLike)\`. Global bindings and module cache do not persist across calls. For Computer Use SDK results, do not console.log/JSON.stringify the complete result or call nodeRepl.emitImage yourself; the SDK submits the structured image/state result and you should use nodeRepl.write for short text-only status. \`get_app_state\` is an explicit observation: assign it to \`const state\`, always call \`nodeRepl.write(state.text)\`, and use \`state.state_id\` plus \`state.elements[*].index\` for element targets; do not leave get_app_state as the final expression or regex state_id from its text. Metadata methods such as list_apps and list_windows may not return action_sent; a missing field is not a failure, so inspect text or structuredContent. Never use screenshot_display.bounds or app/window bounds as raster pixel coordinates; x/y must be integer pixels inside the width/height of the returned raster. Every Computer Use JavaScript call must start with the complete SDK bootstrap in the same cell before agent.computerUse; never split bootstrap and action across calls. Never rely on agent, runtime, browser, or imported bindings from an earlier call. Import only \`node:*\` builtins and absolute \`file://\` URLs built from the official skill root, for example \`await import(pathToFileURL(join(root, "scripts", "client.mjs")).href)\`; bare package specifiers do not resolve. Bootstrap the requested official capability in every call.`;
 
@@ -55102,7 +55097,7 @@ var MAX_SYNC_TIMEOUT_MS = 12e4;
 var UNTRUSTED_SESSION_KEY = "__unscoped__";
 var WORKER_KIND = "dcode-node-repl-call";
 var NODE_REPL_MCP_PROCESS_TITLE = "dcode-node-repl-mcp";
-var pluginRoot = process.env.DCODE_PLUGIN_ROOT ?? process.cwd();
+var pluginRoot = process.env.DCODE_PLUGIN_ROOT ?? process.env.CLAUDE_PLUGIN_ROOT ?? process.cwd();
 var browserDocumentationRoot = resolve(pluginRoot, "docs");
 var cuaDocumentationRoot = resolve(
   process.env.DCODE_CUA_PLUGIN_ROOT ?? pluginRoot,

package/dist/packages/node-repl-host/scripts/build.mjs

@@ -55,6 +55,7 @@ export const buildNodeReplHostBundle = async ({
     outfile,
     platform: "node",
     target: "node24",
+    external: ["sharp"],
   });
   // 构建期守卫：define 名一旦漂移（改名、被 createSharedDefines 之类重构吞掉），
   // 产物会静默退回空串，而症状只在正式包出现且表现为超时。这里立刻失败，别再让它溜到用户手上。