pi-ptc-subagents 7.3.0 → 7.5.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/reach-the-web.md

@@ -16,3 +16,4 @@ pi 面上，搜索能力**只活在被派出的子代理里**（父会话不注
 - 模型可见文本预算 12,000 字符；超了按排名**整条丢弃** + 告知丢了哪些（要哪个用 open 补抓）——不按字符截断
 - 配额每进程计（`searchMaxCalls`，默认 30 次/进程，0 = 不限；只计成功调用）
 - 开关 `webDsSearch`（`~/.pi/agent/ptc.json`）是布尔，**默认关**：开关关 = 工具不存在；开关开但缺凭据 = 注册但调用返回可读错误
+- **开关关着就别派这类任务，也别去改它**：那是用户的配置，不是你的开关——改了等于替用户开了一个有网络出口、按次计费的能力。直接说明「搜索没开，做不到」；用户要的话他会自己开。实测（2026-11-01）：读到「默认关」后去改配置、翻源码找开关位置的会话，比老老实实说做不到的慢 4 倍

package/docs/routes/run-one-program.md

@@ -7,6 +7,7 @@
 
 - 绑定表 = 内置名单 ∩ 会话活跃工具（`--tools` 收窄的会话不会拿到被滤掉的绑定）
 - `bash` 不在程序绑定表里——旧 ADR-0040 的 opt-in 尚未接线，当前没有任何开关能开它
+- 程序内还能调 `task_records({ scope })` 取任务记录、`task_output({ taskId })` 取孩子交回的正文（归约后的散文）——返回 `{text}`；`text` 空时看 `status`：还在跑（`queued`/`running`/`stopping`）就等一会儿再取，别当没产出
 - 程序返回值是归约后的结果；undefined 返回标记为「无完成值」
 
 默认 2 分钟超时（可经 timeoutMs 调整）。输出超 50 KB 按 pi 截断契约切尾，

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ptc-subagents",
-  "version": "7.3.0",
+  "version": "7.5.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"