pi-ptc-subagents 7.2.0 → 7.4.0

package/dist/ptc/worker.js

@@ -0,0 +1,197 @@
+import { stripTypeScriptTypes } from "node:module";
+import { parentPort, workerData } from "node:worker_threads";
+import vm from "node:vm";
+// src/compile.ts
+function compileProgram(source) {
+	return `"use strict";\n${stripTypeScriptTypes(`async function __ptcProgram() {\n${source}\n}`, { mode: "strip" })}\n;globalThis.__ptcProgram = __ptcProgram;`;
+}
+// src/worker-main.ts
+const CELL_PREAMBLE = `"use strict";
+(function () {
+var __bridge = globalThis.__ptcCall;
+var __emit = globalThis.__ptcConsole;
+var __args = JSON.parse(globalThis.__ptcArgsJson);
+// contextified 全局属性不可 delete（vm 限制）但可写——置 undefined 即脱手，桥只剩序言闭包可达
+globalThis.__ptcCall = undefined;
+globalThis.__ptcConsole = undefined;
+globalThis.__ptcArgsJson = undefined;
+function __ptcFmt(v) {
+  if (typeof v === "string") return v;
+  try { var s = JSON.stringify(v); return s === undefined ? String(v) : s; } catch (e) { return String(v); }
+}
+function __ptcJoin(values) {
+  var out = [];
+  for (var i = 0; i < values.length; i++) out.push(__ptcFmt(values[i]));
+  return out.join(" ");
+}
+var __ptcTools = {};
+__PTC_NAMES__.forEach(function (name) {
+  __ptcTools[name] = function (args) {
+    return new Promise(function (resolve, reject) {
+      __bridge(name, JSON.stringify(args === undefined ? null : args)).then(function (json) {
+        var value;
+        try { value = JSON.parse(json); } catch (e) { reject(e); return; }
+        resolve(value);
+      }, reject);
+    });
+  };
+});
+globalThis.tools = Object.freeze(__ptcTools);
+globalThis.console = Object.freeze({
+  log: function () { __emit("log", __ptcJoin(arguments)); },
+  info: function () { __emit("info", __ptcJoin(arguments)); },
+  warn: function () { __emit("warn", __ptcJoin(arguments)); },
+  error: function () { __emit("error", __ptcJoin(arguments)); },
+  debug: function () { __emit("debug", __ptcJoin(arguments)); }
+});
+globalThis.args = Object.freeze(__args);
+if (__PTC_WORKFLOW__) {
+  globalThis.workflow = Object.freeze({
+    log: function () { __emit("log", __ptcJoin(arguments)); },
+    phase: function (name) { __emit("log", "— phase: " + name + " —"); },
+    parallel: function (items) { return Promise.allSettled(items.map(function (run) { return run(); })); },
+    pipeline: function (items, step) {
+      var results = [];
+      return items.reduce(function (chain, item, index) {
+        return chain.then(function () { return Promise.resolve(step(item, index)).then(function (r) { results.push(r); }); });
+      }, Promise.resolve()).then(function () { return results; });
+    }
+  });
+}
+})();
+`;
+function workerMain(deps) {
+	let bindingNames = [];
+	let surface = "run_code";
+	let pending = /* @__PURE__ */ new Map();
+	let nextCallId = 1;
+	let currentRunId = null;
+	let logs = [];
+	deps.onFrame((frame) => {
+		if (frame.kind === "init") {
+			bindingNames = frame.bindingNames;
+			surface = frame.surface;
+			deps.post({ kind: "ready" });
+			return;
+		}
+		if (frame.kind === "reset") {
+			currentRunId = null;
+			for (const { reject } of pending.values()) reject(/* @__PURE__ */ new Error("run reset：worker 被复用"));
+			pending = /* @__PURE__ */ new Map();
+			deps.post({ kind: "ready" });
+			return;
+		}
+		if (frame.kind === "result") {
+			const entry = pending.get(frame.callId);
+			if (!entry) return;
+			pending.delete(frame.callId);
+			if (frame.ok) {
+				let json;
+				try {
+					json = JSON.stringify(frame.value ?? null);
+				} catch {
+					json = void 0;
+				}
+				if (json === void 0) entry.reject(/* @__PURE__ */ new Error("binding 返回值不可 JSON 序列化（如循环引用）"));
+				else entry.resolve(json);
+			} else entry.reject(new Error(frame.error));
+			return;
+		}
+		if (frame.kind === "cancel") return;
+		run(frame.code, frame.id, frame.args);
+	});
+	function preamble() {
+		return CELL_PREAMBLE.replace(/__PTC_NAMES__/g, () => JSON.stringify(bindingNames)).replace(/__PTC_WORKFLOW__/g, () => surface === "workflow" ? "true" : "false");
+	}
+	async function run(code, runId, args) {
+		currentRunId = runId;
+		logs = [];
+		const postLog = (level, text) => {
+			logs.push(text);
+			deps.post({
+				kind: "log",
+				runId,
+				level,
+				text
+			});
+		};
+		const outcome = await execute(code, vm.createContext({
+			__ptcArgsJson: JSON.stringify(args ?? {}),
+			__ptcCall(name, argsJson) {
+				if (currentRunId === null) return Promise.reject(/* @__PURE__ */ new Error("run 已结束：reset 后不再接受工具调用"));
+				let parsed = null;
+				try {
+					parsed = JSON.parse(argsJson);
+				} catch {
+					return Promise.reject(/* @__PURE__ */ new Error("工具参数不是合法 JSON"));
+				}
+				const call = new Promise((resolve, reject) => {
+					const callId = nextCallId++;
+					pending.set(callId, {
+						resolve,
+						reject
+					});
+					deps.post({
+						kind: "call",
+						runId: currentRunId ?? "",
+						callId,
+						name,
+						args: parsed
+					});
+				});
+				call.catch(() => {});
+				return call;
+			},
+			__ptcConsole(level, text) {
+				postLog(level, String(text));
+			}
+		}));
+		deps.post({
+			kind: "settled",
+			runId,
+			outcome
+		});
+	}
+	function errorMessage(error) {
+		if (error instanceof Error) return error.message;
+		if (error && typeof error === "object" && typeof error.message === "string") return error.message;
+		return String(error);
+	}
+	async function execute(code, context) {
+		try {
+			vm.runInContext(preamble(), context, { filename: "ptc_preamble.js" });
+			vm.runInContext(compileProgram(code), context, { filename: "run_code.js" });
+			const value = await context.__ptcProgram.call(context);
+			if (value === void 0) return {
+				status: "fulfilled",
+				value: { $void: true },
+				logs
+			};
+			const json = JSON.stringify(value);
+			if (json === void 0) return {
+				status: "rejected",
+				error: "程序返回值不可序列化",
+				logs
+			};
+			return {
+				status: "fulfilled",
+				value: JSON.parse(json),
+				logs
+			};
+		} catch (error) {
+			return {
+				status: "rejected",
+				error: errorMessage(error),
+				logs
+			};
+		}
+	}
+}
+// src/worker-entry.ts
+if (!parentPort) throw new Error("worker-entry 只能在 worker 线程里加载");
+Object.freeze(workerData);
+workerMain({
+	post: (frame) => parentPort.postMessage(frame),
+	onFrame: (handler) => parentPort.on("message", (frame) => handler(frame))
+});
+export {};

package/docs/routes/create-a-task.md

@@ -15,6 +15,9 @@ agent 定义里的 `tools / model / thinkingLevel / childReport` 由 frontmatter
 任务建成后在任务记录里排队（满员排队不拒绝，ADR-0010），经
 `ptc_task_list / ptc_task_output / ptc_task_stop` 查/停。
 
+任务记录带宿主会话 id（`sessionId`）——按会话筛任务用 `ptc_task_list({ session: "current" })`，
+跨会话的旧记录用 `scope=all` 找。压缩归档（`scope=all`）里的条目也带 `archived: true`。
+
 ## 什么时候值得派（判据）
 
 - **值得**：主题多、彼此独立、每个都要读一堆材料——父一个人扛会算错，一份材料一个孩子最划算。

package/docs/routes/manage-a-task.md

@@ -2,15 +2,69 @@
 
 三个工具，有任务记录才出现在模型面前（ADR-0007：可见性 = 有无记录，不是独立开关）：
 
-- `ptc_task_list()`：在飞的全部 + 最近完成的（默认 10 条）
-- `ptc_task_output({ task_id })`：读一条记录（状态/产出/报告）
+- `ptc_task_list()`：在飞的全部 + 最近完成的任务。响应是对象。
+- `ptc_task_output({ task_id })`：读一条记录。响应是对象。
 - `ptc_task_stop({ task_id, reason? })`：排队中的抽掉（canceled）；在跑的转 stopping
 
-任务记录是派发的唯一痕迹：每次建任务都建记录，前台任务也一样。
+任务记录是派发的唯一痕迹：每次建任务都建记录，等不等也一样建。
 
 终态记录热存留最近 500 条（决策 29），被挤出的进压缩存档（默认留 30 天，
 `archiveEnabled: false` 则直接删），凭精确 task id 经 `ptc_task_output` 仍读得到。
 
+## ptc_task_list
+
+参数：
+
+- `scope`：`recent`（默认，只热存）/ `all`（连压缩归档一起列，更全也更慢）
+- `limit`：取多少条（默认 50，上限 200）
+- `status`：只看某个状态（七个状态之一）
+- `session`：`current` = 本会话，或给一个会话 id
+
+响应：
+
+```json
+{
+  "scope": "recent",
+  "total": 520,
+  "tasks": [
+    {
+      "id": "5d90e136…",
+      "status": "succeeded",
+      "label": "口径汇总",
+      "finishedAt": 1758000123456,
+      "task": "读 AGENTS.md 并汇总六个包的对外口径",
+      "summary": "六个包口径一致"
+    }
+  ]
+}
+```
+
+- `total` = 候选总数。它比 `tasks.length` 大，说明还有更早的记录没列出来。
+- 每条字段各自封顶（task 80 字、summary 100 字、label 120 字）。响应按字节预算逐条裁剪，超预算就停——返回的永远是合法 JSON（不会砍成半截 JSON）。
+- `scope=all` 时归档条目带 `archived: true`。
+- `session` 筛选时条目回显 `sessionId`。老记录没有这个字段，不匹配任何会话。
+
+## ptc_task_output
+
+参数：`task_id`（一条任务记录 id）。
+
+响应 = 那条记录 + 归约层：
+
+- `text`：孩子的散文答案。**交付物是这段正文**，报告只是摘要。正文从事件流现算，不另存一份。
+- 没有正文时给 `output`（原始事件流尾部，50KB 截断，砍头留尾）+ `guidance`（分层引导：先看报告，完整原文在 `outputPath`）。
+- `report`：孩子交的报告（`summary` + `findings`）。孩子没交报告时，这个键整个不存在。
+- `outputPath`：原始事件流的路径。
+
+registry 里记不住的 id 会回落压缩归档（TTL 窗口内仍可解，标 `archived: true`）。
+
+## 程序内检索
+
+`ptc_run_code` 的程序内可调 `tools.task_records({ scope: "all" })`：拿全部任务记录（含压缩归档）。
+
+机械扫描在宿主做，筛选与归约在程序里做。程序只 `return` 要的几条，其余不进上下文。
+
+正则跑在运行格里，运行格有 terminate 兜底；宿主本身没有隔离——病态正则要在程序里跑，别在宿主里跑。
+
 ## 交付核对（delivery）
 
 任务记录与产出里带 `delivery`：**引擎从孩子的进程事件流抽的实测轨迹**，不是孩子的自述。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ptc-subagents",
-  "version": "7.2.0",
+  "version": "7.4.0",
   "description": "Programmable tool calling (PTC) and subagent fan-out for pi",
   "keywords": [
     "pi",
@@ -18,6 +18,9 @@
     "type": "git",
     "url": "git+https://github.com/a1121611810/pi-ptc-subagents.git"
   },
+  "bin": {
+    "ptc": "./dist/ptc/cli.js"
+  },
   "files": [
     "dist/**/*.js",
     "docs/routes/**/*.md",
@@ -27,18 +30,20 @@
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
-    ".": "./dist/index.js"
+    ".": "./dist/index.js",
+    "./ptc": "./dist/ptc/index.js"
   },
   "scripts": {
     "build": "pnpm -r --filter=!@pi-ptc/website run build",
     "build:kimi": "pnpm --filter @pi-ptc/kimi-mcp run build && node scripts/assemble-kimi.mjs",
-    "prepack": "pnpm run build && rm -rf dist docs/routes && cp -R packages/entry/dist dist && cp -R packages/routes/docs/routes docs/routes",
+    "prepack": "pnpm run build && rm -rf dist docs/routes && cp -R packages/entry/dist dist && cp -R packages/ptc/dist dist/ptc && cp -R packages/routes/docs/routes docs/routes",
     "check": "pnpm -r --filter=!@pi-ptc/website run check",
     "lint": "oxlint",
-    "test": "pnpm run test:pi && pnpm run test:output && pnpm run test:kimi",
+    "test": "pnpm run test:pi && pnpm run test:output && pnpm run test:kimi && pnpm run test:standalone",
     "test:pi": "node --test tests/pi/*.test.mjs",
     "test:output": "node --test tests/output/*.test.mjs",
     "test:kimi": "node --test tests/kimi/*.test.mjs",
+    "test:standalone": "node --test tests/standalone/*.test.mjs",
     "pretest": "pnpm run build",
     "fmt": "oxfmt",
     "fmt:check": "oxfmt --check"