@comchatx/cx-subagents 0.1.1 → 0.2.1

package/README.md

@@ -1,43 +1,56 @@
-When a task will take long, such as a research across several data sources or a look through many listings, cx hands it to a helper that runs in the background, tells you it has, and keeps answering you. The helper's result comes back into the conversation by itself.
+When cx hands work to the background, a card for it appears under To do on the board. It holds what cx asked for. When the work is done, the same card shows its result. If it is not done after 30 minutes, the card says 超时 and shows what was done so far.
 
-## When the result comes back
+It needs [`pi-subagents`](https://www.npmjs.com/package/pi-subagents), which runs the work in the background, and [`@comchatx/cx-board`](https://www.npmjs.com/package/@comchatx/cx-board), the board. The Plugins page installs both with it. With pi-subagents alone, cx still works in the background, and no card is written.
 
-A helper runs for at most 30 minutes. When it is done, cx tells you what it found in the conversation; if it is still at work after 30 minutes, cx says it ran out. On cx's computer, at most two helpers run in the background at a time in one conversation: that is ComChatX's setting on the computer, not this package's, and a computer without that setting sets no cap.
-
-## What it costs
+## When cx's computer stops
 
-A helper uses the same model as cx and is paid from the same balance. cx's computer stays on while a helper runs, and that time is billed.
+If cx's computer stops before the work is done, its card stays as it was when the work started.
 
-## When cx's computer stops
+## What it costs
 
-If cx's computer stops before a result is handed back, that result is lost and the work has to run again.
+The work in the background uses the same model as cx and is paid from the same balance. cx's computer stays on while it runs, and that time is billed.
 
 ## How it is built
 
-- **pi-subagents, unchanged.** The helper is [`pi-subagents`](https://www.npmjs.com/package/pi-subagents) and its `subagent` tool. This package names it in its `comchatx` field's `builds`, so the Plugins page installs it with this one; it does not carry it. Its tests run against `pi-subagents` 0.83.0 on pi 1.3.0.
-- **One skill, `cx-subagents`.** It says when cx hands a task to the background (a long research across several sources; a look through many listings), that cx then hands the conversation back and says so, and that the result returns by itself. pi-subagents' own tool asks for an instruction before it delegates; in a ComChatX box this skill is that instruction. Its description says what it needs: pi installs nothing for a package.
-- **pi-subagents' config, carried by the box.** pi-subagents reads `extensions/subagent/config.json` in pi's agent directory once, when it loads, and the Plugins page installs it before this package, so a box's image carries the file instead of this package writing it:
-
-  ```json
-  {
-    "asyncByDefault": true,
-    "toolActivation": "eager",
-    "maxActiveAsyncRunsPerSession": 2
-  }
-  ```
+- **One extension, `extensions/board-cards.ts`.** pi loads it as TypeScript; there is no build. It ships no skill. When cx hands work to the background is cx's own judgement with pi-subagents' `subagent` tool.
+- **What it listens to.** pi-subagents emits `subagent:async-started` and `subagent:async-complete` on the session's event bus. The start carries the run id and the `subagent` call's id, and redacts the task. The extension takes the task from pi's own `tool_call` event for that call. The end carries the result.
+- **The card.** It goes in `board/<person>/todo/` under the session's directory, which in cx's computer is `/tenant`. The person is the one directory under `board/`; a board with none, or with more than one, gets no card. This is the board's shape as `cx-board` describes it. The extension imports nothing from `cx-board` and calls nothing of the board's.
+  - The name is `<YYYYMMDD-HHMMSS>-subagent-<run id>.md`, the start's time in UTC.
+  - The front matter is `kind: finding`, a `title` and an `at`. The title is the task's first line, at most 200 characters. `at` is the start.
+  - The words are the task as given. They are cut where the whole file would pass the 32 KiB the board reads.
+- **At the end** the same file in `todo/` is rewritten, its name, title and `at` kept. The words become:
+  - a single run's own output;
+  - each run's output under its agent's name, for several;
+  - at the deadline, 超时, then what the run had written. pi-subagents' own note on the stop, its "Recovery summary", is left out.
 
-  A run goes to the background unless a call says otherwise; the `subagent` tool is offered from a session's first request; and two background runs at a time in one session, where pi-subagents' own default has no cap. The 30-minute limit is pi-subagents' own default.
-- **What the box does for it.** A background run is a detached Node process of the model's user, so the box counts it as work and stays awake while it runs. Its state lives under `/tmp`, which a stop clears. The box drops the widget pi-subagents sets once a second while a run is in the background, since the page draws none. The notice that wakes cx when a run ends is not drawn; cx's own answer after it is.
+  Nothing is moved. A card the seller has already marked read stays in `done/`, and the result is a card again in `todo/` under the same name. A second start of the same run id overwrites its card. A run that ends after cx's computer stopped leaves its card as it started.
+- **pi-subagents' config is carried by the box,** not this package. `asyncByDefault` sends a run to the background. `toolActivation: "eager"` offers the `subagent` tool from the first request. `maxActiveAsyncRunsPerSession: 2` caps the runs in one conversation at two. The 30 minutes is pi-subagents' own default for a background run.
 
 ## Tests
 
-- `test/package.test.ts`: the pinned pi lists `cx-subagents` beside `pi-subagents`' own skill, with what it needs in its description; the `comchatx` field names the same skills pi lists from this package, with their words, for the Plugins page; the package ships the skill alone and names `pi-subagents` for the page.
-- `test/background.test.ts`, on the pinned pi in RPC mode with a scripted model on loopback, as a box starts pi:
-  - the `subagent` call comes back at once with the run detached;
-  - a second message is answered while the helper is still at work;
-  - the helper's result arrives as pi-subagents' notice, not displayed, and starts the turn in which cx relays it;
-  - with the box's config the session holds `0/2` background runs, and without it `0/unlimited`.
+The tests run against `pi-subagents` 0.85.0 on pi 1.4.0, the versions cx's computer runs.
+
+- **`test/board.test.ts`**, on the pinned pi in RPC mode with a scripted model on loopback, as a box starts pi. Each card is read by the board's own reader, copied into `test/fixtures/board-reader.ts` with its source lines named.
+  - A `subagent` call writes a started card whose title is the task's first line. The result rewrites the same file.
+  - A run stopped at its deadline writes 超时 with what it had.
+  - Two runs write two files.
+  - The same run id started again overwrites its card.
+- **`test/board-cards.test.ts`**, the extension on a bus of its own:
+  - the name and the front matter;
+  - a card found again after a reload;
+  - nothing moved;
+  - the task of a chain or a parallel run;
+  - no card where the board is not one person's;
+  - the 32 KiB cut;
+  - the end's words.
+- **`test/package.test.ts`:**
+  - pi lists no skill from the package and loads its one extension;
+  - the package ships the extension alone;
+  - the package names `pi-subagents` and `@comchatx/cx-board` in `comchatx.builds`.
+- **`test/background.test.ts`:**
+  - a run goes to the background and its result comes back into the conversation;
+  - the box's config caps the runs at two.
 
 ## Release
 
-A maintainer publishes the first version by hand, `npm publish --access public` from a checkout of the merged tag. Each later version is published by `.github/workflows/release.yml` on a `v<version>` tag, once this repository is the package's trusted publisher on npm.
+`.github/workflows/release.yml` publishes each version on a `v<version>` tag, once this repository is the package's trusted publisher on npm. Until then a maintainer publishes by hand, `npm publish --access public` from a checkout of the merged tag.

package/README.zh-CN.md

@@ -0,0 +1,56 @@
+cx 把工作交给后台时，看板的「待处理」下会出现一张对应的卡片，上面写着 cx 交代的内容。工作完成后，同一张卡片会显示结果。如果 30 分钟后仍未完成，卡片会显示「超时」和目前已完成的部分。
+
+它需要在后台运行工作的 [`pi-subagents`](https://www.npmjs.com/package/pi-subagents)，以及看板 [`@comchatx/cx-board`](https://www.npmjs.com/package/@comchatx/cx-board)。「插件」页会一并安装这两个插件。只安装 pi-subagents 时，cx 仍会在后台工作，但不会写卡片。
+
+## cx 的电脑关机时
+
+如果工作完成前 cx 的电脑关机，卡片会保持工作开始时的样子。
+
+## 费用
+
+后台工作和 cx 使用同一个模型，从同一份余额付费。后台工作运行时，cx 的电脑保持开机，开机时长照常计费。
+
+## 实现方式
+
+- **一个扩展：`extensions/board-cards.ts`。** pi 以 TypeScript 直接加载它，不需要构建。它不带任何技能。什么时候把工作交给后台，由 cx 借助 pi-subagents 的 `subagent` 工具自行判断。
+- **它监听什么。** pi-subagents 会在会话的事件总线上发出 `subagent:async-started` 和 `subagent:async-complete`。开始事件带有运行 id 和这次 `subagent` 调用的 id，但隐去了任务内容；扩展从 pi 自己为这次调用发出的 `tool_call` 事件中取得任务。结束事件带有结果。
+- **卡片。** 卡片写在会话文件夹下的 `board/<person>/todo/` 中；在 cx 的电脑上，会话文件夹就是 `/tenant`。这个人就是 `board/` 下唯一的那个文件夹；一个都没有或不止一个时，不写卡片。这是 `cx-board` 所描述的看板结构。扩展不从 `cx-board` 导入任何内容，也不调用看板的任何功能。
+  - 文件名是 `<YYYYMMDD-HHMMSS>-subagent-<run id>.md`，时间是开始时的 UTC 时间。
+  - front matter 包含 `kind: finding`、`title` 和 `at`。标题是任务的第一行，最多 200 个字符；`at` 是开始时间。
+  - 正文是原样的任务内容。整个文件超过看板读取的上限 32 KiB 时，正文会在超出处截断。
+- **结束时**，`todo/` 里的同一个文件会被重写，文件名、标题和 `at` 保持不变。正文变为：
+  - 只有一个运行时，是它自己的输出；
+  - 有多个运行时，是每个运行的输出，分别放在各自智能体的名称下；
+  - 到达时限时，是「超时」，然后是运行已写出的内容；pi-subagents 自己关于这次停止的说明，即它的「Recovery summary」，不会写入。
+
+  不移动任何文件。卖家已标为已读的卡片留在 `done/` 中，结果会以同一个文件名，重新作为卡片出现在 `todo/` 中。同一个运行 id 再次开始时，会覆盖它的卡片。在 cx 的电脑关机后才结束的运行，卡片保持开始时的样子。
+- **pi-subagents 的配置由 cx 的电脑提供**，不在这个包里。`asyncByDefault` 让运行进入后台。`toolActivation: "eager"` 从第一次请求起就提供 `subagent` 工具。`maxActiveAsyncRunsPerSession: 2` 把一个对话中的运行限制为两个。30 分钟是 pi-subagents 对后台运行的默认时限。
+
+## 测试
+
+测试针对 pi 1.4.0 上的 `pi-subagents` 0.85.0 运行，也就是 cx 的电脑上运行的版本。
+
+- **`test/board.test.ts`**：在锁定版本的 pi 上以 RPC 模式运行，使用本机回环地址上的脚本模型，与 cx 的电脑启动 pi 的方式相同。每张卡片都由看板自己的读取器读取，读取器复制在 `test/fixtures/board-reader.ts` 中，并注明了来源行。
+  - 一次 `subagent` 调用会写一张已开始的卡片，标题是任务的第一行；结果会重写同一个文件。
+  - 到时限被停止的运行，写入「超时」和已有的内容。
+  - 两个运行写两个文件。
+  - 同一个运行 id 再次开始，会覆盖它的卡片。
+- **`test/board-cards.test.ts`**：扩展在独立的事件总线上：
+  - 文件名和 front matter；
+  - 重新加载后再次找到卡片；
+  - 不移动任何文件；
+  - 链式运行或并行运行的任务；
+  - 看板不属于单独一个人时，不写卡片；
+  - 32 KiB 截断；
+  - 结束时的正文。
+- **`test/package.test.ts`**：
+  - pi 不会从这个包列出任何技能，并加载它唯一的扩展；
+  - 这个包只发布这个扩展；
+  - 这个包在 `comchatx.builds` 中写明 `pi-subagents` 和 `@comchatx/cx-board`。
+- **`test/background.test.ts`**：
+  - 运行进入后台，结果回到对话中；
+  - cx 的电脑上的配置把运行限制为两个。
+
+## 发布
+
+本仓库成为这个包在 npm 上的可信发布者后，每个版本会在打上 `v<version>` 标签时由 `.github/workflows/release.yml` 发布。在此之前，由维护者从合并后的标签检出代码，手动运行 `npm publish --access public` 发布。

package/extensions/board-cards.ts

@@ -0,0 +1,162 @@
+import { mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+/** pi-subagents' events for a background run, on the session's bus (`pi-subagents` `src/shared/types.js`). */
+export const STARTED = "subagent:async-started";
+export const COMPLETE = "subagent:async-complete";
+export const TIMED_OUT_WORDS = "超时";
+
+/** The board's shape (`parts/cx-board.md` §1): one directory per person under `board/`, cards waiting in its `todo/`. */
+const BOARD = "board";
+const TODO = "todo";
+const DONE = "done";
+const PERSON = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+/** The most of one file the board reads; a larger one is drawn as its name alone. */
+export const CARD_MAX_BYTES = 32 * 1024;
+const TITLE_MAX = 200;
+/** The `subagent` calls whose words are kept, the latest, for a start that names its call after the call's own result. */
+const ASKED_KEPT = 64;
+
+type Card = { readonly name: string; readonly title: string; readonly at: number };
+type Options = { readonly now?: () => number };
+
+const text = (value: unknown): string | undefined => (typeof value === "string" ? value : undefined);
+const record = (value: unknown): Record<string, unknown> => (typeof value === "object" && value !== null ? (value as Record<string, unknown>) : {});
+
+/** What a `subagent` call asked: its task, or each step's of a chain or a parallel run, as given. */
+function taskOf(input: Record<string, unknown>): string {
+  const own = text(input["task"]);
+  if (own !== undefined && own.trim() !== "") return own;
+  const steps = [input["tasks"], input["chain"]].flatMap((list) => (Array.isArray(list) ? list : [])).map((step) => text(record(step)["task"]) ?? "").filter((one) => one.trim() !== "");
+  return steps.join("\n\n");
+}
+
+const firstLine = (task: string): string => {
+  const line = (task.split(/\r?\n/).find((one) => one.trim() !== "") ?? "").replace(/\s+/g, " ").trim();
+  return line.length > TITLE_MAX ? `${line.slice(0, TITLE_MAX - 1)}…` : line;
+};
+
+const stamp = (ms: number): string => new Date(ms).toISOString().replace(/[-:]/g, "").replace("T", "-").slice(0, 15);
+const idPart = (id: string): string => id.replace(/[^A-Za-z0-9_-]/g, "-").slice(0, 80);
+const suffix = (id: string): string => `-subagent-${idPart(id)}.md`;
+
+/** A card as the board reads it: front matter with its kind, title and time, then the words, cut to what the board reads whole. */
+export function cardText(card: Card, words: string): string {
+  const head = `---\nkind: finding\ntitle: ${JSON.stringify(card.title)}\nat: ${new Date(card.at).toISOString()}\n---\n\n`;
+  const room = CARD_MAX_BYTES - Buffer.byteLength(head) - 1;
+  const body = Buffer.byteLength(words) <= room ? words : `${Buffer.from(words).subarray(0, room - 3).toString().replace(/�+$/, "")}…`;
+  return `${head}${body}\n`;
+}
+
+/** The one person's board under the session's directory, or none when there is not exactly one. */
+function personDir(cwd: string): string | undefined {
+  let people: string[];
+  try {
+    people = readdirSync(join(cwd, BOARD), { withFileTypes: true }).filter((one) => one.isDirectory()).map((one) => one.name);
+  } catch {
+    return undefined;
+  }
+  return people.length === 1 && PERSON.test(people[0]!) ? join(cwd, BOARD, people[0]!) : undefined;
+}
+
+/** A run's card already on the board, by its run id: in `todo/`, else where the seller moved it, with its title and time read back. */
+function found(person: string, id: string, now: number): Card | undefined {
+  for (const place of [TODO, DONE]) {
+    let names: string[];
+    try { names = readdirSync(join(person, place)); } catch { continue; }
+    const name = names.filter((one) => one.endsWith(suffix(id)) && !one.startsWith(".")).sort().at(-1);
+    if (name === undefined) continue;
+    let lines: string[] = [];
+    try { lines = readFileSync(join(person, place, name), "utf8").split(/\r?\n/); } catch { /* the name alone */ }
+    const field = (key: string): string | undefined => lines.find((line) => line.startsWith(`${key}: `))?.slice(key.length + 2);
+    let title = field("title") ?? "";
+    try { title = JSON.parse(title) as string; } catch { /* as it stands */ }
+    const at = Date.parse(field("at") ?? "");
+    return { name, title, at: Number.isFinite(at) ? at : now };
+  }
+  return undefined;
+}
+
+/** Writes a card into `todo/` whole, so the board never reads half of one. */
+function write(person: string, card: Card, words: string): void {
+  const dir = join(person, TODO);
+  mkdirSync(dir, { recursive: true });
+  const temp = join(dir, `.${card.name}.${process.pid}.tmp`);
+  writeFileSync(temp, cardText(card, words));
+  renameSync(temp, join(dir, card.name));
+}
+
+/** Where pi-subagents' own note on a stopped run begins, after what the helper had written: paths and checks, not the helper's words. */
+const RECOVERY = "\n\nRecovery summary:";
+const ownWords = (result: Record<string, unknown>): string => {
+  const output = text(result["output"]) ?? "";
+  const cut = output.indexOf(RECOVERY);
+  return (cut < 0 ? output : output.slice(0, cut)).trim();
+};
+
+/**
+ * A run's end as its card's words: a single helper's own output, or each helper's of several under its agent's name; at the deadline,
+ * 「超时」 and what the run had when pi-subagents stopped it.
+ */
+export function endWords(event: Record<string, unknown>): string {
+  const timedOut = event["timedOut"] === true;
+  const results = Array.isArray(event["results"]) ? event["results"].map(record) : [];
+  const each = results.map((result) => ({ agent: text(result["agent"]) ?? "", words: ownWords(result) || (timedOut ? "" : (text(result["error"]) ?? "").trim()) }));
+  const words = each.length === 1 ? each[0]!.words : each.filter((one) => one.words !== "").map((one) => `${one.agent}:\n${one.words}`).join("\n\n");
+  if (timedOut) return words === "" ? TIMED_OUT_WORDS : `${TIMED_OUT_WORDS}\n\n${words}`;
+  return words !== "" ? words : (text(event["summary"]) ?? text(event["error"]) ?? "").trim();
+}
+
+/**
+ * Each background run of pi-subagents is a card on the board: at its start, the task's first line as the title, the start as its time and
+ * the task as its words; at its end, the same file in `todo/` with the result as its words. Nothing is moved; a card the seller already
+ * moved to `done/` stays there, and the result is a card again in `todo/` under the same name.
+ */
+export function boardCards(pi: ExtensionAPI, options: Options = {}): void {
+  const now = options.now ?? Date.now;
+  const asked = new Map<string, string>();
+  const running = new Set<string>();
+  const cards = new Map<string, Card>();
+  let cwd = process.cwd();
+
+  pi.on("session_start", (_event, ctx) => { cwd = ctx.cwd; });
+  pi.on("tool_call", (event, ctx) => {
+    cwd = ctx.cwd;
+    if (event.toolName !== "subagent") return;
+    asked.set(event.toolCallId, taskOf(record(event.input)));
+    running.add(event.toolCallId);
+    for (const old of asked.keys()) if (asked.size > ASKED_KEPT) asked.delete(old);
+  });
+  pi.on("tool_result", (event) => { running.delete(event.toolCallId); });
+
+  pi.events.on(STARTED, (data) => {
+    const event = record(data);
+    const id = text(event["id"]);
+    const person = personDir(cwd);
+    if (id === undefined || person === undefined) return;
+    const toolCallId = text(event["toolCallId"]);
+    const own = toolCallId === undefined ? undefined : asked.get(toolCallId);
+    const task = own ?? (running.size === 1 ? asked.get([...running][0]!) : undefined) ?? "";
+    const at = now();
+    const before = cards.get(id) ?? found(person, id, at);
+    const card = { name: before?.name ?? `${stamp(at)}${suffix(id)}`, title: firstLine(task) || (text(event["agent"]) ?? "subagent"), at };
+    cards.set(id, card);
+    write(person, card, task);
+  });
+
+  pi.events.on(COMPLETE, (data) => {
+    const event = record(data);
+    const id = text(event["id"]) ?? text(event["runId"]);
+    const person = personDir(cwd);
+    if (id === undefined || person === undefined) return;
+    const at = now();
+    const card = cards.get(id) ?? found(person, id, at) ?? { name: `${stamp(at)}${suffix(id)}`, title: "", at };
+    cards.delete(id);
+    write(person, { ...card, title: card.title || (text(event["agent"]) ?? "subagent") }, endWords(event));
+  });
+}
+
+export default function (pi: ExtensionAPI): void {
+  boardCards(pi);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@comchatx/cx-subagents",
-  "version": "0.1.1",
-  "description": "Lets cx hand a long task to a helper in the background and keep answering you; the result comes back into the conversation by itself.",
+  "version": "0.2.1",
+  "description": "Puts what cx does in the background on the board.",
   "license": "MIT",
   "author": "ComChatX",
   "homepage": "https://github.com/comchatx/cx-subagents#readme",
@@ -15,40 +15,34 @@
   ],
   "type": "module",
   "pi": {
-    "skills": [
-      "./skills"
+    "extensions": [
+      "./extensions/board-cards.ts"
     ]
   },
   "files": [
-    "skills"
+    "extensions",
+    "README.zh-CN.md"
   ],
   "scripts": {
     "typecheck": "tsc --noEmit",
     "test": "vitest run"
   },
   "comchatx": {
-    "about": "让 cx 把耗时的任务交给后台助手，自己继续回答你。",
-    "description": "任务要花很长时间时，比如跨几个数据源做调研、逐个查看大量 listing，cx 会把它交给一个在后台运行的助手，告诉你它这样做了，然后继续回答你。助手的结果会自己回到对话里。\n\n## 结果什么时候回来\n\n助手最多运行 30 分钟。做完时，cx 会在对话里告诉你结果；到 30 分钟还没做完，cx 会说它超时了。在 cx 的电脑上，同一个对话里最多同时有两个助手在后台运行：这是 ComChatX 在电脑上的设置，不是这个插件的；没有这项设置的电脑不限个数。\n\n## 费用\n\n助手和 cx 用同一个模型，由同一份余额付费。助手运行时，cx 的电脑保持开机，开机时长也要付费。\n\n## 电脑关机时\n\n如果 cx 的电脑在结果交回之前关机，这个结果就丢了，需要重新运行。",
+    "about": "把 cx 在后台做的事放到看板上。",
     "mark": {
       "line": "rocket"
     },
     "section": "extensions",
     "builds": [
-      "pi-subagents"
-    ],
-    "skills": {
-      "cx-subagents": {
-        "about": {
-          "en": "Lets cx hand a long task to a helper in the background and keep answering; the result comes back into the conversation.",
-          "zh": "让 cx 把耗时的任务交给后台助手并继续回答；结果会回到对话里。"
-        }
-      }
-    }
+      "pi-subagents",
+      "@comchatx/cx-board"
+    ]
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "1.3.0",
+    "@earendil-works/pi-coding-agent": "1.4.0",
     "@types/node": "26.2.0",
-    "pi-subagents": "0.83.0",
+    "@vitest/coverage-v8": "4.1.11",
+    "pi-subagents": "0.85.0",
     "typescript": "7.0.2",
     "vitest": "4.1.11"
   }

package/skills/cx-subagents/SKILL.md

@@ -1,23 +0,0 @@
----
-name: cx-subagents
-description: "When a task will take long - a research across several data sources, a look through many listings - cx hands it to a helper in the background with pi-subagents' `subagent` tool, tells the seller it has, and keeps answering; the helper's result comes back into the conversation on its own. Needs pi-subagents; if no `subagent` tool is offered, it is not installed, and the seller installs it in Plugins."
----
-
-## When a task goes to the background
-
-- A research across several data sources, or a look through many listings: work that would hold the conversation for minutes.
-- The seller asked for the work. In this box that is the instruction to hand a long piece of it to a helper; ask nothing more first.
-- Not for a quick answer, a single read, or a step whose result the next answer needs at once: do those in the conversation.
-
-## How
-
-- Call `subagent` with one agent and the whole task in your own words: what to look at, what to bring back. Leave `async` out: a run goes to the background here.
-- Then hand the conversation back: tell the seller in one sentence that the work runs in the background and that its result will come here, and answer whatever they ask next.
-- On cx's computer at most two helpers run at a time in one conversation, by ComChatX's setting on the computer, and a third is refused until one ends; a computer without that setting sets no cap.
-
-## When it comes back
-
-- The result arrives by itself, as a message that starts a turn of yours. Tell the seller what the helper found, in your words, as the answer to what they asked for.
-- A helper stops at 30 minutes, and its message says so: tell the seller it ran out, and offer to split the work.
-- If cx's computer stops before a result is handed back, that result is lost. If the seller asks after a stop, say so and offer to run it again.
-- A helper uses the same model as you, paid from the same balance, and cx's computer stays on while it runs.