u1s1-cli 1.13.2 → 1.14.1

package/dist/workflow/runner.js

@@ -1,349 +0,0 @@
-import { createHash } from "node:crypto";
-import { execFileSync } from "node:child_process";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import vm from "node:vm";
-import { dirname, resolve } from "node:path";
-import { tr } from "../i18n.js";
-import { runPool, runSubagent, SUBAGENT_CONCURRENCY } from "../subagent.js";
-// ---- WorkflowRunner:执行模型生成的编排脚本(路线 A:主进程 vm 上下文) ----
-// 定位「防误不防恶」:vm 非硬安全边界,靠白名单注入 + 静态校验 + 脚本落盘可审查兜底。
-/** 整个 run 的默认墙钟上限。 */
-export const WORKFLOW_TIMEOUT_MS = 30 * 60_000;
-/** 单个子任务的超时(与 spawn_subagent 工具一致)。 */
-const PER_TASK_TIMEOUT_MS = 15 * 60_000;
-/** 报告里最多保留多少行脚本 log 输出。 */
-const MAX_LOG_LINES = 60;
-/** 默认整个 run 的 token 预算;0 或负数表示不设限。 */
-export const WORKFLOW_DEFAULT_BUDGET_TOKENS = 20_000_000;
-/** JSONL 进度存档:一行一个已完成的子任务,断点续跑时按 key 跳过。 */
-export class ProgressStore {
-    path;
-    #cache = new Map();
-    constructor(path) {
-        this.path = path;
-        mkdirSync(dirname(path), { recursive: true });
-        if (!existsSync(path))
-            return;
-        for (const line of readFileSync(path, "utf8").split("\n")) {
-            if (!line.trim())
-                continue;
-            try {
-                const e = JSON.parse(line);
-                if (typeof e.key === "string")
-                    this.#cache.set(e.key, e);
-            }
-            catch {
-                // 尾部半行(进程被杀)直接忽略
-            }
-        }
-    }
-    getSuccessful(key) {
-        const entry = this.#cache.get(key);
-        return entry?.ok === true && typeof entry.text === "string" ? entry : undefined;
-    }
-    append(entry) {
-        this.#cache.set(entry.key, entry);
-        appendFileSync(this.path, `${JSON.stringify(entry)}\n`);
-    }
-}
-/**
- * 断点续跑的任务标识:任务内容 + 模型的哈希。
- * 前提是脚本确定性好 —— 相同任务串在续跑时视为同一任务(循环里重复相同任务串
- * 的场景续跑粒度不精确,W1 接受此限制;i18n 这类每项任务内容唯一的场景完全够用)。
- */
-function taskKey(task, model) {
-    return createHash("sha1").update(`${task}|${model ?? ""}`).digest("hex").slice(0, 16);
-}
-/** 去掉注释和字符串字面量后再扫禁用模式,避免文档式注释误报。 */
-function stripCommentsAndStrings(code) {
-    return code
-        .replace(/\/\*[\s\S]*?\*\//g, " ")
-        .replace(/(^|[^:])\/\/[^\n]*/g, "$1 ")
-        .replace(/"(?:[^"\\\n]|\\.)*"/g, '""')
-        .replace(/'(?:[^'\\\n]|\\.)*'/g, "''")
-        .replace(/`(?:[^`\\]|\\.)*`/g, "``");
-}
-/** 静态白名单校验:语法能编译 + 不碰沙箱之外的任何能力。 */
-export function validateScript(code) {
-    const errors = [];
-    try {
-        // 与执行时同款包装,保证报错行号一致
-        new vm.Script(`(async () => {\n${code}\n})()`, { filename: "workflow.mjs" });
-    }
-    catch (e) {
-        errors.push(tr(`语法错误:${e.message}`, `Syntax error: ${e.message}`));
-        return errors;
-    }
-    const bare = stripCommentsAndStrings(code);
-    const forbidden = [
-        [/\brequire\s*\(/, "require()"],
-        [/\bimport\s*\(/, tr("动态 import()", "dynamic import()")],
-        [/^\s*import\s/m, tr("静态 import", "static import")],
-        [/\bprocess\b/, tr("process 对象", "the process object")],
-        [/\bglobalThis\b/, "globalThis"],
-        [/\bfetch\s*\(/, "fetch()"],
-        [/\beval\s*\(/, "eval()"],
-        [/\bFunction\s*\(/, "new Function()"],
-        [/\.constructor\b/, tr(".constructor(原型链逃逸)", ".constructor (prototype-chain escape)")],
-        [/\bprototype\b/, tr("prototype(原型链逃逸)", "prototype (prototype-chain escape)")],
-        [/\b__proto__\b/, "__proto__"],
-        [/\bWebAssembly\b/, "WebAssembly"],
-        [/node:/, tr("node: 内置模块", "node: built-in modules")],
-        [/child_process/, "child_process"],
-        [/\bfs\b\s*\./, tr("fs 模块", "the fs module")],
-    ];
-    for (const [re, label] of forbidden) {
-        if (re.test(bare))
-            errors.push(tr(`脚本使用了沙箱之外的能力:${label}`, `The script uses something outside the sandbox: ${label}`));
-    }
-    return errors;
-}
-/** 执行一个 workflow 脚本,返回给主对话的报告。不抛错——失败也进报告让模型自行修复。 */
-export async function runWorkflow(opts) {
-    const started = Date.now();
-    const logs = [];
-    const stats = { spawns: 0, ok: 0, failed: 0, cached: 0 };
-    // 内部中止控制器:父会话 ESC 或整体超时都会触发,并传导到每个子 session
-    const internal = new AbortController();
-    const onParentAbort = () => internal.abort(opts.signal?.reason);
-    opts.signal?.addEventListener("abort", onParentAbort, { once: true });
-    let timedOut = false;
-    const overallTimer = setTimeout(() => {
-        timedOut = true;
-        const minutes = Math.round((opts.timeoutMs ?? WORKFLOW_TIMEOUT_MS) / 60_000);
-        internal.abort(new Error(tr(`整个工作流超时(${minutes} 分钟)`, `The workflow timed out (${minutes} minutes)`)));
-    }, opts.timeoutMs ?? WORKFLOW_TIMEOUT_MS);
-    const store = new ProgressStore(opts.progressPath);
-    const budgetTokens = opts.budgetTokens ?? WORKFLOW_DEFAULT_BUDGET_TOKENS;
-    let spentTokens = 0;
-    let running = 0;
-    const progress = { spawns: 0, ok: 0, failed: 0, cached: 0, running: 0, spentTokens: 0, budgetTokens };
-    const reportProgress = () => {
-        progress.spentTokens = spentTokens;
-        opts.onProgress?.({ ...progress });
-    };
-    /** git worktree 隔离:在 .u1s1/worktrees/ 下建临时工作树,返回其路径。 */
-    let worktreeSeq = 0;
-    function createTempWorktree() {
-        const dir = resolve(workflowsDir(), "../../.u1s1-worktrees", `wf-${Date.now()}-${++worktreeSeq}`);
-        execFileSync("git", ["worktree", "add", "--detach", dir], { stdio: "pipe" });
-        return dir;
-    }
-    function removeWorktree(dir) {
-        try {
-            execFileSync("git", ["worktree", "remove", "--force", dir], { stdio: "pipe" });
-        }
-        catch {
-            rmSync(dir, { recursive: true, force: true });
-            try {
-                execFileSync("git", ["worktree", "prune"], { stdio: "pipe" });
-            }
-            catch {
-                // 尽力清理即可
-            }
-        }
-    }
-    /** 注入沙箱的 subagent():字符串或 {task, model, worktree} 都行,返回最终输出文本。 */
-    async function subagentImpl(input) {
-        const o = typeof input === "string" ? { task: input } : (input ?? {});
-        const task = typeof o.task === "string" ? o.task.trim() : "";
-        if (!task)
-            throw new Error(tr("subagent() 需要 task 字符串", "subagent() needs a task string"));
-        const model = typeof o.model === "string" && o.model ? o.model : undefined;
-        if (internal.signal.aborted)
-            throw new Error(tr("工作流已中止,不再派发新子任务", "The workflow was aborted; no new subtasks will be started"));
-        if (budgetTokens > 0 && spentTokens >= budgetTokens) {
-            throw new Error(tr(`token 预算已用尽(已用 ${spentTokens.toLocaleString()} / 上限 ${budgetTokens.toLocaleString()}),不再派发新子任务`, `Token budget exhausted (used ${spentTokens.toLocaleString()} / limit ${budgetTokens.toLocaleString()}); no new subtasks will be started`));
-        }
-        const key = taskKey(task, model);
-        if (opts.resume) {
-            const prev = store.getSuccessful(key);
-            if (prev) {
-                stats.cached++;
-                progress.cached = stats.cached;
-                reportProgress();
-                return prev.text;
-            }
-        }
-        stats.spawns++;
-        progress.spawns = stats.spawns;
-        running++;
-        progress.running = running;
-        reportProgress();
-        const t0 = Date.now();
-        let worktreeDir;
-        if (o.worktree === true)
-            worktreeDir = createTempWorktree();
-        try {
-            const out = await runSubagent({
-                task,
-                model,
-                parentModel: opts.parentModel,
-                timeoutMs: PER_TASK_TIMEOUT_MS,
-                signal: internal.signal,
-                cwd: worktreeDir,
-                // 临时 worktree 永远不在 trust.json 里:信任裁决按源仓库(主进程 cwd)算
-                projectTrusted: opts.projectTrusted,
-                trustCwd: process.cwd(),
-                noTools: o.noTools === true,
-            });
-            stats.ok++;
-            progress.ok = stats.ok;
-            spentTokens += out.usage.totalTokens;
-            store.append({ key, task: task.slice(0, 120), ok: true, text: out.text, ms: Date.now() - t0 });
-            return out.text;
-        }
-        catch (error) {
-            stats.failed++;
-            progress.failed = stats.failed;
-            const msg = error.message || tr("未知错误", "Unknown error");
-            store.append({ key, task: task.slice(0, 120), ok: false, text: msg, ms: Date.now() - t0 });
-            throw new Error(msg, { cause: error });
-        }
-        finally {
-            if (worktreeDir)
-                removeWorktree(worktreeDir);
-            running--;
-            progress.running = running;
-            reportProgress();
-        }
-    }
-    /** 注入沙箱的 judge():廉价无工具模型调用,严格回答 PASS/FAIL,转成布尔。 */
-    async function judgeImpl(question) {
-        if (typeof question !== "string" || !question.trim())
-            throw new Error(tr("judge() 需要问题字符串", "judge() needs a question string"));
-        const answer = await subagentImpl({
-            task: tr(`回答以下判定问题。只允许回答一个词:PASS 或 FAIL,不要任何其他内容。\n\n判定问题:${question.trim()}`, `Answer the following yes/no check. Reply with exactly one word, PASS or FAIL, and nothing else.\n\nCheck: ${question.trim()}`),
-            noTools: true,
-        });
-        const pass = /\bPASS\b/i.test(answer) && !/\bFAIL\b/i.test(answer);
-        if (!pass && !/\bFAIL\b/i.test(answer))
-            logs.push(tr(`⚠ judge 回答无法解析,按 FAIL 处理:${answer.slice(0, 120)}`, `⚠ Couldn't parse the judge answer; treating it as FAIL: ${answer.slice(0, 120)}`));
-        return pass;
-    }
-    /** barrier 扇出:全部并发(封顶排队),单个失败该项为 null,不拖垮整批。 */
-    async function parallel(thunks) {
-        if (!Array.isArray(thunks))
-            throw new Error(tr("parallel() 需要一个 thunk 数组", "parallel() needs an array of thunks"));
-        const results = [];
-        await runPool({
-            items: thunks,
-            limit: SUBAGENT_CONCURRENCY,
-            run: async (thunk, i) => {
-                results[i] = await Promise.resolve()
-                    .then(thunk)
-                    .catch((e) => {
-                    logs.push(tr(`✗ 任务 ${i + 1} 失败:${e.message}`, `✗ Task ${i + 1} failed: ${e.message}`));
-                    return null;
-                });
-            },
-            signal: internal.signal,
-        });
-        return results;
-    }
-    /** 无屏障流水线:每个 item 独立穿过所有 stage,item 失败只废自己。 */
-    async function pipeline(items, stages) {
-        if (!Array.isArray(items))
-            throw new Error(tr("pipeline() 第一个参数需要数组", "pipeline() needs an array as its first argument"));
-        if (!Array.isArray(stages) || stages.length === 0)
-            throw new Error(tr("pipeline() 第二个参数需要非空 stage 数组", "pipeline() needs a non-empty array of stages as its second argument"));
-        const results = [];
-        await runPool({
-            items: items,
-            limit: SUBAGENT_CONCURRENCY,
-            run: async (item, i) => {
-                let current = item;
-                for (let s = 0; s < stages.length; s++) {
-                    try {
-                        current = await stages[s](current);
-                    }
-                    catch (e) {
-                        logs.push(tr(`✗ item ${i + 1} 在第 ${s + 1} 阶段失败:${e.message}`, `✗ Item ${i + 1} failed at stage ${s + 1}: ${e.message}`));
-                        current = null;
-                        break;
-                    }
-                }
-                results[i] = current;
-            },
-            signal: internal.signal,
-        });
-        return results;
-    }
-    // 沙箱:只有编排原语 + 受限 log/timer,标准 JS 内建(Promise/JSON/Math…)天然可用
-    const fmtLogArg = (a) => typeof a === "string" ? a : (() => { try {
-        return JSON.stringify(a);
-    }
-    catch {
-        return String(a);
-    } })();
-    const pushLog = (...args) => {
-        if (logs.length < 500)
-            logs.push(args.map(fmtLogArg).join(" "));
-    };
-    const sandbox = {
-        subagent: subagentImpl,
-        parallel,
-        pipeline,
-        judge: judgeImpl,
-        log: pushLog,
-        console: { log: pushLog, info: pushLog, warn: pushLog, error: pushLog },
-        setTimeout: (fn, ms) => setTimeout(fn, Math.max(0, Math.min(Number(ms) || 0, 120_000))),
-        clearTimeout,
-    };
-    let scriptError;
-    let completionValue;
-    try {
-        // 包成 async IIFE:支持顶层 await 和 return;line 数与校验时一致
-        const script = new vm.Script(`(async () => {\n${opts.code}\n})()`, { filename: "workflow.mjs" });
-        const ctx = vm.createContext(sandbox);
-        completionValue = await Promise.resolve().then(() => script.runInContext(ctx));
-    }
-    catch (e) {
-        scriptError = e.stack?.split("\n").slice(0, 3).join("\n") || e.message;
-    }
-    finally {
-        clearTimeout(overallTimer);
-        opts.signal?.removeEventListener("abort", onParentAbort);
-    }
-    const seconds = Math.round((Date.now() - started) / 1000);
-    const aborted = internal.signal.aborted;
-    const budgetExhausted = budgetTokens > 0 && spentTokens >= budgetTokens;
-    const details = { ...stats, seconds, aborted, spentTokens, budgetExhausted };
-    const header = tr(`工作流结束,用时 ${seconds}s · 子任务 ✓${stats.ok} ✗${stats.failed}${stats.cached ? ` · 续跑命中 ${stats.cached}` : ""} · 用 ${spentTokens.toLocaleString()} tokens${budgetTokens > 0 ? ` / 预算 ${budgetTokens.toLocaleString()}` : " (不限)"}${timedOut ? " · ⏱ 整体超时" : ""}${aborted && !timedOut ? " · 已中止" : ""}`, `Workflow finished in ${seconds}s · subtasks ✓${stats.ok} ✗${stats.failed}${stats.cached ? ` · resumed from cache ${stats.cached}` : ""} · used ${spentTokens.toLocaleString()} tokens${budgetTokens > 0 ? ` / budget ${budgetTokens.toLocaleString()}` : " (no limit)"}${timedOut ? " · ⏱ timed out" : ""}${aborted && !timedOut ? " · aborted" : ""}`);
-    const lines = [header, ""];
-    if (completionValue !== undefined) {
-        let shown;
-        try {
-            shown = JSON.stringify(completionValue, null, 2) ?? String(completionValue);
-        }
-        catch {
-            shown = String(completionValue);
-        }
-        lines.push(tr("**返回值**", "**Return value**"), "", shown.slice(0, 3000), "");
-    }
-    if (scriptError)
-        lines.push(tr("**脚本报错**", "**Script error**"), "", "```", scriptError, "```", "");
-    if (logs.length > 0) {
-        lines.push(tr("**运行日志**", "**Run log**"), "", ...logs.slice(0, MAX_LOG_LINES).map((l) => `- ${l.slice(0, 300)}`));
-        if (logs.length > MAX_LOG_LINES) {
-            lines.push(tr(`- …(另有 ${logs.length - MAX_LOG_LINES} 条省略)`, `- … (${logs.length - MAX_LOG_LINES} more omitted)`));
-        }
-        lines.push("");
-    }
-    lines.push(tr(`进度存档:${opts.progressPath}(失败重跑可加 resume=true 续跑)`, `Progress saved to: ${opts.progressPath} (to rerun after failures, add resume=true to continue)`));
-    return { report: lines.join("\n").trim(), details };
-}
-/** 工作区目录:项目根 .u1s1/workflows/(脚本 + 进度存档都在这里)。 */
-export function workflowsDir() {
-    const dir = resolve(process.cwd(), ".u1s1/workflows");
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-/** 内联脚本落盘,返回脚本路径(进度存档按同名约定派生)。 */
-export function saveWorkflowScript(code) {
-    const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/T(\d{6}).*/, "-$1");
-    const path = resolve(workflowsDir(), `wf-${stamp}.mjs`);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, code);
-    return path;
-}

package/dist/workflow/templates.d.ts

@@ -1,11 +0,0 @@
-export interface WorkflowTemplate {
-    name: string;
-    description: string;
-    /** 生成脚本源码;input 已由调用方做过形状校验。 */
-    build: (input: Record<string, unknown>) => string;
-    /** 给模型看的 input 说明。 */
-    inputHint: string;
-}
-export declare const TEMPLATES: Record<string, WorkflowTemplate>;
-/** 按模板名生成脚本;生成后自检必须过静态校验(防模板本身写出不合规代码)。 */
-export declare function buildFromTemplate(template: string, input: Record<string, unknown>): string;

package/dist/workflow/templates.js

@@ -1,200 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { tr } from "../i18n.js";
-import { validateScript } from "./runner.js";
-function str(v, fallback = "") {
-    return typeof v === "string" && v.trim() ? v.trim() : fallback;
-}
-function strArray(v) {
-    return Array.isArray(v)
-        ? v.filter((x) => typeof x === "string" && !!x.trim()).map((x) => x.trim())
-        : [];
-}
-/** JSON.stringify 后内插进脚本;保证引号安全。 */
-function lit(v) {
-    return JSON.stringify(v ?? null);
-}
-/** 脚本里给子 agent 的任务文案:按界面语言取中/英,再经 lit() 成为脚本里的字符串字面量。 */
-function q(zh, en) {
-    return lit(tr(zh, en));
-}
-/** git 改动文件列表(模板构建期在主进程执行,不进沙箱)。
- * 剔除已删除文件(评审/重构 agent 没法打开),并入未跟踪的新文件。 */
-function gitDiffFiles() {
-    const run = (args) => {
-        const out = execFileSync("git", args, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
-        return out.split("\n").map((s) => s.trim()).filter(Boolean);
-    };
-    try {
-        const changed = run(["diff", "--name-only", "--diff-filter=d", "HEAD"]);
-        const untracked = run(["ls-files", "--others", "--exclude-standard"]);
-        return [...new Set([...changed, ...untracked])];
-    }
-    catch {
-        return [];
-    }
-}
-export const TEMPLATES = {
-    i18n: {
-        name: "i18n",
-        get description() {
-            return tr("批量多语言翻译:每个语言一个子 agent 并行翻译,完成后统一校验 key 对齐并自动修复", "Batch translation: one sub-agent per language translates in parallel, then a final pass checks key alignment and fixes issues");
-        },
-        get inputHint() {
-            return tr('{ "langs": ["en", "ja", "de"], "source": "src/locales/zh.json", "dir": "src/locales" } — source/dir 可省略(默认 src/locales/zh.json 与同目录)', '{ "langs": ["en", "ja", "de"], "source": "src/locales/zh.json", "dir": "src/locales" } — source/dir are optional (default: src/locales/zh.json and its directory)');
-        },
-        build(input) {
-            const langs = strArray(input.langs);
-            if (langs.length === 0) {
-                throw new Error(tr('i18n 模板需要 langs 数组,例如 { "langs": ["en", "ja"] }', 'The i18n template needs a langs array, e.g. { "langs": ["en", "ja"] }'));
-            }
-            const source = str(input.source, "src/locales/zh.json");
-            const dir = str(input.dir, source.includes("/") ? source.slice(0, source.lastIndexOf("/")) : "src/locales");
-            // 用户输入一律经 lit() 进脚本,再在运行期拼接——裸内插遇到引号/反斜杠/换行会把生成的脚本弄成语法错误
-            return `
-const langs = ${lit(langs)};
-const source = ${lit(source)};
-const dir = ${lit(dir)};
-log(${q("i18n:翻译 ", "i18n: translating ")} + langs.length + ${q(" 个语言,源文件 ", " languages, source file ")} + source);
-const results = await parallel(langs.map(lang => () =>
-  subagent({
-    task: ${q("读取 ", "Read ")} + source + ${q(",把所有文案翻译成对应语言(保持所有 key 不变、输出合法 JSON、译文自然地道),", " and translate all strings into the target language (keep every key unchanged, output valid JSON, make the translation natural and idiomatic), ")} +
-      ${q("写入 ", "and write it to ")} + dir + "/" + lang + ${q(".json。写完后重新读一遍文件,确认是合法 JSON 且 key 与源文件完全一致。", ".json. After writing, re-read the file to confirm it is valid JSON and its keys exactly match the source file. ")} +
-      ${q("目标语言代码:", "Target language code: ")} + lang
-  })
-));
-const okLangs = langs.filter((_, i) => results[i] !== null);
-if (okLangs.length > 0) {
-  await subagent({
-    task: ${q("对照 ", "Compare against ")} + source + ${q(" 检查 ", " and check the translation files under ")} + dir + ${q("/ 目录下这些语言的翻译文件:", "/ for these languages: ")} + okLangs.join(",") + "." +
-      ${q("逐个核对 key 是否与源文件完全一致、JSON 是否合法、译文是否有明显机翻痕迹,发现问题直接修复。最后汇报每个语言的状态", " For each one, verify the keys exactly match the source, the JSON is valid, and the translation doesn't read like obvious machine translation; fix any problems directly. Finally, report the status of each language")}
-  });
-}
-return { translated: okLangs, failed: langs.filter(l => !okLangs.includes(l)) };
-`;
-        },
-    },
-    review: {
-        name: "review",
-        get description() {
-            return tr("全面代码审查:每个文件一个评审 agent 并行审查,发现项再交独立 agent 对抗性验证,只保留核实为真的问题", "Thorough code review: one reviewer agent per file in parallel, then an independent agent adversarially verifies the findings and keeps only confirmed issues");
-        },
-        get inputHint() {
-            return tr('{ "files": ["src/a.ts", "src/b.ts"] } — files 可省略,默认取 git diff --name-only HEAD 的改动文件', '{ "files": ["src/a.ts", "src/b.ts"] } — files is optional; defaults to the changed files from git diff --name-only HEAD');
-        },
-        build(input) {
-            let files = strArray(input.files);
-            if (files.length === 0)
-                files = gitDiffFiles();
-            if (files.length === 0) {
-                throw new Error(tr("review 模板需要 files 数组,或当前仓库有未提交改动", "The review template needs a files array, or uncommitted changes in the current repository"));
-            }
-            return `
-const files = ${lit(files)};
-log(${q("review:评审 ", "review: reviewing ")} + files.length + ${q(" 个文件,发现项将做对抗性验证", " files; findings will be adversarially verified")});
-const reports = await parallel(files.map(f => () =>
-  subagent({
-    task: ${q("通读 ", "Read ")} + f + ${q(" 及其直接依赖,做代码审查:正确性 bug、安全漏洞、明显的性能问题。", " and its direct dependencies, and review the code for correctness bugs, security vulnerabilities, and obvious performance problems. ")} +
-      ${q("只报告有把握的问题,每条给出文件、行号、严重程度(高/中/低)、问题描述和建议修法。没有问题就明确说无发现。", "Only report issues you are confident about; for each, give the file, line number, severity (high/medium/low), a description, and a suggested fix. If there are none, say explicitly that there are no findings.")}
-  })
-));
-const findings = reports.filter(Boolean).join("\\n\\n---\\n\\n");
-if (!findings.trim()) return { verified: ${q("(所有文件均无发现)", "(no findings in any file)")} };
-const verified = await subagent({
-  task: ${q("下面是一份代码审查发现列表。逐条对抗性验证:打开涉及的文件核对,剔除不成立、夸大或已过时的条目,", "Below is a list of code review findings. Adversarially verify each one: open the files involved to check, drop entries that are wrong, exaggerated, or outdated, ")} +
-    ${q("只保留核实为真的问题,按严重程度排序输出完整清单。\n\n", "keep only issues confirmed to be real, and output the complete list sorted by severity.\n\n")} + findings
-});
-return { verified };
-`;
-        },
-    },
-    research: {
-        name: "research",
-        get description() {
-            return tr("并行研究:每个方向一个子 agent 独立调查(可联网),最后汇总成一份综合报告", "Parallel research: one sub-agent investigates each question independently (with web access), then the results are merged into one report");
-        },
-        get inputHint() {
-            return tr('{ "questions": ["方向一", "方向二"], "context": "可选背景" }', '{ "questions": ["question 1", "question 2"], "context": "optional background" }');
-        },
-        build(input) {
-            const questions = strArray(input.questions);
-            if (questions.length === 0)
-                throw new Error(tr('research 模板需要 questions 数组,例如 { "questions": ["竞品A的定价", "竞品B的功能"] }', 'The research template needs a questions array, e.g. { "questions": ["Competitor A pricing", "Competitor B features"] }'));
-            const context = str(input.context);
-            const contextLine = context ? tr(`调查背景:${context}。`, `Background: ${context}. `) : "";
-            return `
-const questions = ${lit(questions)};
-const contextLine = ${lit(contextLine)};
-log(${q("research:并行调查 ", "research: investigating ")} + questions.length + ${q(" 个方向", " questions in parallel")});
-const reports = await parallel(questions.map(q => () =>
-  subagent({
-    task: ${q("调查以下问题,可以用 web_search/web_fetch 联网,也可以读本地代码和文档。", "Investigate the question below. You can use web_search/web_fetch to search the web, and you can also read local code and docs. ")} +
-      ${q("输出:关键事实(带来源)、不同观点、你的结论。", "Output: key facts (with sources), differing views, and your conclusion. ")} + contextLine + ${q("问题:", "Question: ")} + q
-  })
-));
-const merged = reports
-  .map((r, i) => (r ? ${q("## 方向 ", "## Question ")} + (i + 1) + ${q(":", ": ")} + questions[i] + "\\n\\n" + r : null))
-  .filter(Boolean)
-  .join("\\n\\n");
-if (!merged.trim()) return { synthesis: ${q("(所有方向都失败了)", "(all questions failed)")}, failed: questions.length };
-const synthesis = await subagent({
-  task: ${q("把以下几份调查报告综合成一份结论性报告:先给核心结论(不超过 5 条),再给分方向要点,", "Synthesize the following research reports into one conclusive report: start with the core conclusions (at most 5), then key points per question, ")} +
-    ${q("最后列分歧点和待确认项。不要编造报告里没有的信息。\n\n", "and finally list disagreements and open items. Do not invent information that isn't in the reports.\n\n")} + merged
-});
-return { synthesis };
-`;
-        },
-    },
-    refactor: {
-        name: "refactor",
-        get description() {
-            return tr("批量重构/迁移:先由一个 agent 读代表文件制定统一规则,然后每个文件一个子 agent 在当前工作区套用规则", "Batch refactor/migration: one agent reads representative files and writes a single set of rules, then one sub-agent per file applies them in the current working tree");
-        },
-        get inputHint() {
-            return tr('{ "instruction": "把所有 var 改为 const", "files": ["src/a.ts", ...] } — files 省略时用 git diff 改动文件', '{ "instruction": "change every var to const", "files": ["src/a.ts", ...] } — if files is omitted, the git diff changed files are used');
-        },
-        build(input) {
-            const instruction = str(input.instruction);
-            if (!instruction) {
-                throw new Error(tr('refactor 模板需要 instruction,例如 { "instruction": "把 var 全部改为 const" }', 'The refactor template needs an instruction, e.g. { "instruction": "change every var to const" }'));
-            }
-            // 与 review 模板一致:构建期取 git 改动文件,不花一个 subagent 在沙箱里跑 git
-            let files = [...new Set(strArray(input.files))];
-            if (files.length === 0)
-                files = gitDiffFiles();
-            if (files.length === 0) {
-                throw new Error(tr("refactor 模板需要 files 数组,或当前仓库有未提交改动", "The refactor template needs a files array, or uncommitted changes in the current repository"));
-            }
-            return `
-const instruction = ${lit(instruction)};
-const targetFiles = ${lit(files)};
-log(${q("refactor:共 ", "refactor: ")} + targetFiles.length + ${q(" 个文件,先制定统一规则", " files; drafting a common set of rules first")});
-const rule = await subagent({
-  task: ${q("我们要对一批文件做统一重构:", "We are applying the same refactor to a batch of files: ")} + instruction + ${q("。", ". ")} +
-    ${q("先读其中 1-2 个代表性文件了解现状,然后输出一份精确的重构规则清单(每条:什么模式改成什么、边界情况怎么处理)。", "First read 1-2 representative files to understand the current state, then output a precise list of refactoring rules (each: which pattern becomes what, and how to handle edge cases). ")} +
-    ${q("规则要具体到可以直接照做,不要空话。涉及文件:", "Make the rules concrete enough to follow directly; no vague advice. Files involved: ")} + targetFiles.slice(0, 10).join(",")
-});
-const results = await parallel(targetFiles.map(f => () =>
-  subagent({
-    task: ${q("按以下重构规则处理文件 ", "Apply the refactoring rules below to the file ")} + f + ${q("。只修改这个目标文件,不要改动其他文件,避免与并行任务冲突。", ". Only modify this target file; do not change any other files, to avoid conflicts with parallel tasks. ")} +
-      ${q("改完检查该文件语法正确(必要时运行 tsc 或构建验证)。\n\n重构规则:\n", "When done, check that the file's syntax is correct (run tsc or a build to verify if needed).\n\nRefactoring rules:\n")} + rule
-  })
-));
-const done = targetFiles.filter((_, i) => results[i] !== null);
-return { applied: done, failed: targetFiles.filter(f => !done.includes(f)), rule };
-`;
-        },
-    },
-};
-/** 按模板名生成脚本;生成后自检必须过静态校验(防模板本身写出不合规代码)。 */
-export function buildFromTemplate(template, input) {
-    const t = TEMPLATES[template];
-    if (!t) {
-        throw new Error(tr(`未知模板 "${template}",可用:${Object.keys(TEMPLATES).join(", ")}`, `Unknown template "${template}"; available: ${Object.keys(TEMPLATES).join(", ")}`));
-    }
-    const code = t.build(input ?? {});
-    const errors = validateScript(code);
-    if (errors.length > 0) {
-        throw new Error(tr(`模板 ${template} 生成的脚本未通过静态校验(模板 bug,请反馈):${errors.join(";")}`, `The script generated by template ${template} failed static validation (template bug, please report it): ${errors.join("; ")}`));
-    }
-    return code;
-}

package/dist/workflow/tool.d.ts

@@ -1,16 +0,0 @@
-import { Type } from "typebox";
-import { type ParentModelRef } from "../subagent.js";
-/**
- * run_workflow 工具:主 agent 把模型生成的编排脚本交给 WorkflowRunner 执行。
- * 脚本在 vm 沙箱里跑,只能用注入的 subagent/parallel/pipeline 原语。
- */
-export declare function createRunWorkflowTool(getParentModel: () => ParentModelRef): import("@earendil-works/pi-coding-agent").ToolDefinition<Type.TObject<{
-    script: Type.TOptional<Type.TString>;
-    template: Type.TOptional<Type.TString>;
-    input: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
-    script_path: Type.TOptional<Type.TString>;
-    save_as: Type.TOptional<Type.TString>;
-    resume: Type.TOptional<Type.TBoolean>;
-    timeout_minutes: Type.TOptional<Type.TNumber>;
-    budget_tokens: Type.TOptional<Type.TNumber>;
-}>, unknown, any> & import("@earendil-works/pi-coding-agent").ToolDefinition<any, any, any>;