@maxiaochao/pi-toolkit 0.10.5 → 0.10.7

package/packages/scheduler/extensions/scheduler.ts

@@ -0,0 +1,133 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import { Scheduler, systemClock, type ScheduleSnapshot } from "../src/scheduler.ts";
+
+const Params = Type.Object({
+	action: StringEnum(["add", "list", "trigger", "cancel"] as const),
+	every: Type.Optional(Type.String({ description: "Interval for add, for example 30s, 5m, or 1h30m" })),
+	prompt: Type.Optional(Type.String({ description: "Prompt delivered to the main agent on each trigger" })),
+	id: Type.Optional(Type.String({ description: "Schedule ID for trigger or cancel" })),
+});
+
+function formatTime(timestamp: number): string {
+	return new Date(timestamp).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+
+function formatList(schedules: ScheduleSnapshot[]): string {
+	if (schedules.length === 0) return "No active schedules.";
+	return schedules.map((item) =>
+		`${item.id} · every ${item.every} · next ${formatTime(item.nextRunAt)}${item.pending ? " · prompt pending" : ""}\n  ${item.prompt}`,
+	).join("\n");
+}
+
+function parseCommand(input: string): { action: "add" | "list" | "trigger" | "cancel"; every?: string; prompt?: string; id?: string } {
+	const text = input.trim();
+	if (!text || text === "list") return { action: "list" };
+	const [action, first, ...rest] = text.split(/\s+/);
+	if (action === "add") return { action, every: first, prompt: rest.join(" ") };
+	if (action === "trigger" || action === "cancel") return { action, id: first };
+	throw new Error("usage: /schedule add <interval> <prompt> | list | trigger <id> | cancel <id>");
+}
+
+export default function (pi: ExtensionAPI) {
+	if (process.env.PI_HERDR_SUBAGENTS_CHILD === "1") return;
+	let context: ExtensionContext | undefined;
+
+	const refreshStatus = () => {
+		if (!context?.hasUI) return;
+		const schedules = scheduler.list();
+		const next = schedules[0];
+		context.ui.setStatus("scheduler", next ? `⏱ ${schedules.length} schedule${schedules.length === 1 ? "" : "s"} · next ${formatTime(next.nextRunAt)}` : undefined);
+	};
+
+	const scheduler = new Scheduler({
+		clock: systemClock,
+		onChange: refreshStatus,
+		onTrigger(schedule, source) {
+			pi.sendMessage({
+				customType: "scheduler-trigger",
+				content: `[Scheduled prompt: ${schedule.id}; source=${source}]\n${schedule.prompt}`,
+				display: true,
+				details: { scheduleId: schedule.id, source, every: schedule.every },
+			}, { triggerTurn: true, deliverAs: "followUp" });
+		},
+	});
+
+	const perform = (params: { action: "add" | "list" | "trigger" | "cancel"; every?: string; prompt?: string; id?: string }) => {
+		if (params.action === "add") {
+			if (!params.every || !params.prompt) throw new Error("add requires every and prompt");
+			const item = scheduler.add(params.every, params.prompt);
+			return `Created ${item.id}: every ${item.every}; next ${formatTime(item.nextRunAt)}.`;
+		}
+		if (params.action === "list") return formatList(scheduler.list());
+		if (!params.id) throw new Error(`${params.action} requires id`);
+		if (params.action === "cancel") {
+			if (!scheduler.cancel(params.id)) throw new Error(`unknown schedule: ${params.id}`);
+			return `Cancelled ${params.id}. Already queued prompts cannot be withdrawn.`;
+		}
+		const result = scheduler.trigger(params.id);
+		if (!result.ok) {
+			if (result.reason === "already-pending") throw new Error(`${params.id} already has a pending prompt`);
+			throw new Error(`unknown schedule: ${params.id}`);
+		}
+		return `Triggered ${params.id}; its regular next time is unchanged.`;
+	};
+
+	pi.on("session_start", async (_event, ctx) => {
+		context = ctx;
+		refreshStatus();
+	});
+	pi.on("message_start", async (event) => {
+		if (event.message.role !== "custom" || event.message.customType !== "scheduler-trigger") return;
+		const details = event.message.details as { scheduleId?: unknown } | undefined;
+		if (typeof details?.scheduleId === "string") scheduler.acknowledge(details.scheduleId);
+	});
+	pi.on("agent_settled", async () => {
+		// A queued follow-up can be cleared by Pi before it produces message_start.
+		// Once the run is fully settled, any still-pending scheduler message is gone.
+		scheduler.releaseUndelivered();
+	});
+	pi.on("session_shutdown", async (_event, ctx) => {
+		scheduler.clear();
+		if (ctx.hasUI) ctx.ui.setStatus("scheduler", undefined);
+		context = undefined;
+	});
+
+	pi.registerTool({
+		name: "schedule",
+		label: "Schedule",
+		description: "Manage session-scoped interval prompts for the main agent. Use add when the user asks the agent to check something repeatedly. Use trigger for one immediate check without changing the regular cadence. Schedules end with the current session.",
+		parameters: Params,
+		annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+		async execute(_toolCallId, params) {
+			try {
+				const text = perform(params);
+				return { content: [{ type: "text" as const, text }], details: { ...params, schedules: scheduler.list() } };
+			} catch (error) {
+				const text = error instanceof Error ? error.message : String(error);
+				return { content: [{ type: "text" as const, text: `Error: ${text}` }], details: { ...params, error: text }, isError: true };
+			}
+		},
+		renderCall(args, theme) {
+			return new Text(`${theme.fg("toolTitle", theme.bold("schedule "))}${theme.fg("muted", args.action)}`, 0, 0);
+		},
+		renderResult(result, _options, theme) {
+			const item = result.content[0];
+			return new Text(theme.fg(result.isError ? "error" : "muted", item?.type === "text" ? item.text : ""), 0, 0);
+		},
+	});
+
+	pi.registerCommand("schedule", {
+		description: "Add, list, trigger, or cancel session-scoped interval prompts",
+		handler: async (args, ctx) => {
+			try {
+				const text = perform(parseCommand(args));
+				ctx.ui.notify(text, "info");
+			} catch (error) {
+				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
+}

package/packages/{todo → scheduler}/package.json

@@ -1,16 +1,16 @@
 {
-  "name": "@maxiaochao/pi-todo",
+  "name": "@maxiaochao/pi-scheduler",
   "version": "0.1.0",
-  "description": "Branch-local execution-plan lifecycle and history extension for Pi.",
+  "description": "Session-scoped interval prompts for Pi agents.",
   "type": "module",
-  "keywords": ["pi-package", "pi-extension", "todo"],
+  "keywords": ["pi-package", "pi-extension", "scheduler"],
   "files": ["extensions", "src", "docs", "README.md", "TESTING.md", "CHANGELOG.md"],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/chaochaoxiaochao/pi-toolkit.git",
-    "directory": "packages/todo"
+    "directory": "packages/scheduler"
   },
-  "pi": { "extensions": ["./extensions/todo.ts"] },
+  "pi": { "extensions": ["./extensions/scheduler.ts"] },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
@@ -18,8 +18,8 @@
     "typebox": "*"
   },
   "scripts": {
-    "test": "node --experimental-strip-types tests/todo-state.mjs && node --experimental-strip-types tests/todo-extension.mjs",
-    "load-test": "pi -ne -e ./extensions/todo.ts"
+    "test": "node --experimental-strip-types tests/scheduler-core.mjs && node --experimental-strip-types tests/scheduler-extension.mjs",
+    "load-test": "pi -ne -e ./extensions/scheduler.ts"
   },
   "publishConfig": { "access": "public" }
 }

package/packages/scheduler/src/scheduler.ts

@@ -0,0 +1,171 @@
+export interface Clock {
+	now(): number;
+	setTimeout(callback: () => void, delayMs: number): unknown;
+	clearTimeout(handle: unknown): void;
+}
+
+export interface ScheduleSnapshot {
+	id: string;
+	every: string;
+	intervalMs: number;
+	prompt: string;
+	nextRunAt: number;
+	pending: boolean;
+}
+
+interface Schedule extends ScheduleSnapshot {
+	timer?: unknown;
+}
+
+export interface TriggerResult {
+	ok: boolean;
+	reason?: "not-found" | "already-pending";
+	schedule?: ScheduleSnapshot;
+}
+
+const DURATION_PART = /(\d+)(ms|s|m|h|d)/gy;
+const MAX_INTERVAL_MS = 7 * 24 * 60 * 60 * 1000;
+
+export function parseDuration(input: string): number {
+	const value = input.trim().toLowerCase();
+	if (!value) throw new Error("interval is required");
+	let total = 0;
+	let offset = 0;
+	for (const match of value.matchAll(DURATION_PART)) {
+		if (match.index !== offset) throw new Error(`invalid interval: ${input}`);
+		const amount = Number(match[1]);
+		const unit = match[2];
+		const multiplier = unit === "ms" ? 1 : unit === "s" ? 1_000 : unit === "m" ? 60_000 : unit === "h" ? 3_600_000 : 86_400_000;
+		total += amount * multiplier;
+		offset = match.index + match[0].length;
+	}
+	if (offset !== value.length || total < 1_000 || total > MAX_INTERVAL_MS) {
+		throw new Error("interval must be between 1s and 7d (examples: 30s, 5m, 1h30m)");
+	}
+	return total;
+}
+
+export class Scheduler {
+	private readonly clock: Clock;
+	private readonly onTrigger: (schedule: ScheduleSnapshot, source: "timer" | "manual") => void;
+	private readonly onChange: () => void;
+	private readonly schedules = new Map<string, Schedule>();
+	private nextId = 1;
+
+	constructor(options: {
+		clock: Clock;
+		onTrigger: (schedule: ScheduleSnapshot, source: "timer" | "manual") => void;
+		onChange?: () => void;
+	}) {
+		this.clock = options.clock;
+		this.onTrigger = options.onTrigger;
+		this.onChange = options.onChange ?? (() => {});
+	}
+
+	add(every: string, prompt: string): ScheduleSnapshot {
+		const intervalMs = parseDuration(every);
+		const normalizedPrompt = prompt.trim();
+		if (!normalizedPrompt) throw new Error("prompt is required");
+		const schedule: Schedule = {
+			id: `schedule-${this.nextId++}`,
+			every: every.trim(),
+			intervalMs,
+			prompt: normalizedPrompt,
+			nextRunAt: this.clock.now() + intervalMs,
+			pending: false,
+		};
+		this.schedules.set(schedule.id, schedule);
+		this.arm(schedule);
+		this.onChange();
+		return this.snapshot(schedule);
+	}
+
+	list(): ScheduleSnapshot[] {
+		return [...this.schedules.values()]
+			.sort((left, right) => left.nextRunAt - right.nextRunAt || left.id.localeCompare(right.id))
+			.map((schedule) => this.snapshot(schedule));
+	}
+
+	trigger(id: string): TriggerResult {
+		const schedule = this.schedules.get(id);
+		if (!schedule) return { ok: false, reason: "not-found" };
+		if (schedule.pending) return { ok: false, reason: "already-pending", schedule: this.snapshot(schedule) };
+		this.fire(schedule, "manual");
+		return { ok: true, schedule: this.snapshot(schedule) };
+	}
+
+	cancel(id: string): boolean {
+		const schedule = this.schedules.get(id);
+		if (!schedule) return false;
+		if (schedule.timer !== undefined) this.clock.clearTimeout(schedule.timer);
+		this.schedules.delete(id);
+		this.onChange();
+		return true;
+	}
+
+	acknowledge(id: string): boolean {
+		const schedule = this.schedules.get(id);
+		if (!schedule?.pending) return false;
+		schedule.pending = false;
+		this.onChange();
+		return true;
+	}
+
+	releaseUndelivered(): number {
+		let released = 0;
+		for (const schedule of this.schedules.values()) {
+			if (!schedule.pending) continue;
+			schedule.pending = false;
+			released += 1;
+		}
+		if (released > 0) this.onChange();
+		return released;
+	}
+
+	clear(): void {
+		for (const schedule of this.schedules.values()) {
+			if (schedule.timer !== undefined) this.clock.clearTimeout(schedule.timer);
+		}
+		this.schedules.clear();
+		this.onChange();
+	}
+
+	private arm(schedule: Schedule): void {
+		const delay = Math.max(0, schedule.nextRunAt - this.clock.now());
+		schedule.timer = this.clock.setTimeout(() => this.tick(schedule.id), delay);
+	}
+
+	private tick(id: string): void {
+		const schedule = this.schedules.get(id);
+		if (!schedule) return;
+		const now = this.clock.now();
+		do schedule.nextRunAt += schedule.intervalMs;
+		while (schedule.nextRunAt <= now);
+		if (!schedule.pending) this.fire(schedule, "timer");
+		this.arm(schedule);
+		this.onChange();
+	}
+
+	private fire(schedule: Schedule, source: "timer" | "manual"): void {
+		schedule.pending = true;
+		this.onTrigger(this.snapshot(schedule), source);
+		this.onChange();
+	}
+
+	private snapshot(schedule: Schedule): ScheduleSnapshot {
+		return {
+			id: schedule.id,
+			every: schedule.every,
+			intervalMs: schedule.intervalMs,
+			prompt: schedule.prompt,
+			nextRunAt: schedule.nextRunAt,
+			pending: schedule.pending,
+		};
+	}
+}
+
+export const systemClock: Clock = {
+	now: () => Date.now(),
+	setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+	clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
+};

package/packages/scheduler/tests/scheduler-core.mjs

@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import { Scheduler, parseDuration } from "../src/scheduler.ts";
+
+class FakeClock {
+	nowMs = 1_000_000;
+	nextHandle = 1;
+	timers = new Map();
+	now() { return this.nowMs; }
+	setTimeout(callback, delayMs) {
+		const handle = this.nextHandle++;
+		this.timers.set(handle, { at: this.nowMs + delayMs, callback });
+		return handle;
+	}
+	clearTimeout(handle) { this.timers.delete(handle); }
+	advance(ms) {
+		this.nowMs += ms;
+		while (true) {
+			const due = [...this.timers.entries()].filter(([, timer]) => timer.at <= this.nowMs).sort((a, b) => a[1].at - b[1].at)[0];
+			if (!due) break;
+			this.timers.delete(due[0]);
+			due[1].callback();
+		}
+	}
+}
+
+assert.equal(parseDuration("5m"), 300_000);
+assert.equal(parseDuration("1h30m"), 5_400_000);
+assert.throws(() => parseDuration("cron * * * * *"), /interval/);
+assert.throws(() => parseDuration("500ms"), /between 1s and 7d/);
+
+const clock = new FakeClock();
+const triggers = [];
+let changes = 0;
+const scheduler = new Scheduler({ clock, onTrigger: (schedule, source) => triggers.push({ schedule, source }), onChange: () => { changes += 1; } });
+const added = scheduler.add("5m", "Check CI and report only if finished or failed");
+assert.equal(added.id, "schedule-1");
+assert.equal(added.nextRunAt, 1_300_000);
+assert.equal(scheduler.list().length, 1);
+
+clock.advance(300_000);
+assert.equal(triggers.length, 1);
+assert.equal(triggers[0].source, "timer");
+assert.equal(scheduler.list()[0].pending, true);
+assert.equal(scheduler.list()[0].nextRunAt, 1_600_000);
+
+clock.advance(900_000);
+assert.equal(triggers.length, 1, "missed intervals coalesce while one prompt is pending");
+assert.equal(scheduler.list()[0].nextRunAt, 2_500_000, "absolute cadence skips missed intervals without drift");
+assert.equal(scheduler.acknowledge(added.id), true);
+assert.equal(scheduler.acknowledge(added.id), false);
+assert.equal(scheduler.trigger(added.id).ok, true);
+assert.equal(triggers.at(-1).source, "manual");
+assert.equal(scheduler.list()[0].nextRunAt, 2_500_000, "manual trigger preserves regular cadence");
+assert.deepEqual(scheduler.trigger(added.id).reason, "already-pending");
+assert.equal(scheduler.releaseUndelivered(), 1);
+assert.equal(scheduler.releaseUndelivered(), 0);
+assert.equal(scheduler.trigger(added.id).ok, true, "a settled run releases a follow-up that never entered message_start");
+
+assert.equal(scheduler.cancel(added.id), true);
+assert.equal(scheduler.cancel(added.id), false);
+assert.equal(scheduler.list().length, 0);
+assert.ok(changes >= 5);
+console.log("Scheduler core tests passed");

package/packages/scheduler/tests/scheduler-extension.mjs

@@ -0,0 +1,81 @@
+import assert from "node:assert/strict";
+import registerScheduler from "../extensions/scheduler.ts";
+
+const handlers = new Map();
+const commands = new Map();
+const messages = [];
+const statuses = new Map();
+let tool;
+const originalSetTimeout = globalThis.setTimeout;
+const originalClearTimeout = globalThis.clearTimeout;
+let nextTimer = 1;
+const timers = new Map();
+globalThis.setTimeout = (callback, delayMs) => {
+	const id = nextTimer++;
+	timers.set(id, { callback, delayMs });
+	return id;
+};
+globalThis.clearTimeout = (id) => timers.delete(id);
+const pi = {
+	on(name, handler) { handlers.set(name, handler); },
+	registerTool(definition) { tool = definition; },
+	registerCommand(name, definition) { commands.set(name, definition); },
+	sendMessage(message, options) { messages.push({ message, options }); },
+};
+const childGuard = process.env.PI_HERDR_SUBAGENTS_CHILD;
+delete process.env.PI_HERDR_SUBAGENTS_CHILD;
+try {
+	registerScheduler(pi);
+} finally {
+	if (childGuard === undefined) delete process.env.PI_HERDR_SUBAGENTS_CHILD;
+	else process.env.PI_HERDR_SUBAGENTS_CHILD = childGuard;
+}
+const notifications = [];
+const asAppMessage = ({ message }) => ({ ...message, role: "custom" });
+const context = {
+	hasUI: true,
+	ui: {
+		setStatus(key, value) { if (value === undefined) statuses.delete(key); else statuses.set(key, value); },
+		notify(message, level) { notifications.push({ message, level }); },
+	},
+};
+await handlers.get("session_start")({}, context);
+assert.ok(tool);
+assert.ok(commands.has("schedule"));
+
+const add = await tool.execute("add", { action: "add", every: "1h", prompt: "Check CI" });
+assert.match(add.content[0].text, /Created schedule-1/);
+assert.match(statuses.get("scheduler"), /1 schedule/);
+
+const trigger = await tool.execute("trigger", { action: "trigger", id: "schedule-1" });
+assert.match(trigger.content[0].text, /Triggered schedule-1/);
+assert.equal(messages.length, 1);
+assert.deepEqual(messages[0].options, { triggerTurn: true, deliverAs: "followUp" });
+assert.match(messages[0].message.content, /\[Scheduled prompt: schedule-1; source=manual\]\nCheck CI/);
+const duplicate = await tool.execute("trigger-again", { action: "trigger", id: "schedule-1" });
+assert.equal(duplicate.isError, true);
+
+await handlers.get("message_start")({ message: { role: "custom", customType: "other", details: { scheduleId: "schedule-1" } } });
+assert.equal((await tool.execute("still-pending", { action: "trigger", id: "schedule-1" })).isError, true, "unrelated custom messages do not acknowledge a schedule");
+await handlers.get("message_start")({ message: asAppMessage(messages[0]) });
+await commands.get("schedule").handler("trigger schedule-1", context);
+assert.equal(messages.length, 2);
+assert.match(notifications.at(-1).message, /regular next time is unchanged/);
+await commands.get("schedule").handler("list", context);
+assert.match(notifications.at(-1).message, /schedule-1/);
+
+await handlers.get("agent_settled")({ aborted: false });
+await commands.get("schedule").handler("trigger schedule-1", context);
+assert.equal(messages.length, 3, "settlement releases a queued scheduler message that never reached message_start");
+await handlers.get("message_start")({ message: asAppMessage(messages[2]) });
+await commands.get("schedule").handler("cancel schedule-1", context);
+assert.match(notifications.at(-1).message, /Already queued prompts cannot be withdrawn/);
+assert.equal(statuses.has("scheduler"), false);
+await tool.execute("shutdown-add", { action: "add", every: "2h", prompt: "Check deployment" });
+assert.equal(timers.size, 1, "active schedule owns one timer");
+await handlers.get("session_shutdown")({}, context);
+assert.equal(statuses.has("scheduler"), false);
+assert.equal(timers.size, 0, "session shutdown clears active timers");
+globalThis.setTimeout = originalSetTimeout;
+globalThis.clearTimeout = originalClearTimeout;
+console.log("Scheduler extension integration tests passed");

package/skills/agent-team/SKILL.md

@@ -4,86 +4,62 @@ description: 以对抗评审的方式让不同厂商的模型交叉验证同一
 disable-model-invocation: true
 ---
 
-当前会话是**管理者**，不是转述人：自己也承担一份实证工作，并对每一轮的裁决负责。队员是长驻的 herdr pane，不是一次性 subagent —— 它们要能被反复追问、被点名互相反驳。
+当前会话是**管理者**，不是转述人：自己也承担一份实证工作，并对每一轮的裁决负责。每轮并发启动三个相互独立的子代理，统一收集结果后由管理者裁决。子代理不需要常驻；跨轮连续性来自持久调查档案和逻辑成员身份，而不是聊天记忆。
 
 ## 何时值得开
 
-只在用户要求组队时开，它会在用户的终端里真的分屏。值得开的条件：结论会驱动一个代价高的动作（改内核、下线设备、向客户定责），或者证据链已经长到单模型会自我确认。查一个事实、读一份文件用不上。
+只在用户要求组队时开。值得开的条件：结论会驱动一个代价高的动作（改内核、下线设备、向客户定责），或者证据链已经长到单模型容易自我确认。查一个事实、读一份文件用不上。
 
-## 1. 建队
+## 1. 建立调查档案
 
-**必须跨厂商。** 同厂同代模型共享盲区，三个一起点头等于一个点头。
+为当前问题建立 `.pi/agent-team/<case>/`：
 
-名单在同目录的 `models.json`，先读它，照里面的 `model` 字段写命令；用户指定了别的模型就用用户的。每个成员有 `name` / `model` / `role` / `charter`，`defaults` 里是共用的 `kind` 与 `thinking`。
-
-```bash
-herdr pane split --current --direction right --cwd "$PWD" --no-focus
-herdr agent start <name> --kind pi --pane <pane> -- --model <model> --thinking <thinking>
-echo <pane> > /tmp/pane_<name>
+```text
+.pi/agent-team/<case>/
+├── BRIEF.md              # 问题、范围、术语、输入和排除项
+├── FINDINGS-stageN.md    # 当前唯一事实源；新阶段整体取代旧阶段
+├── LEDGER.md             # 只增不改的 N/X 记录
+└── rounds/
+    └── N.md              # 本轮角色映射和可证伪攻击点
 ```
 
-pane id 落盘，后面所有广播脚本都从这里取。开完把该成员的 `charter` 作为第一条 prompt 发过去，立常设职责。`herdr agent list` 确认都是 idle 再开工。
+`BRIEF.md` 只记录稳定背景。`FINDINGS-stageN.md` 必含机制链、编号发现、已推翻清单和未闭合点。`LEDGER.md` 中发现按 `N1, N2…` 追加，被推翻的结论按 `X1, X2…` 追加并写明推翻者。只有管理者能更新这三个权威文件；子代理只提交候选证据。
 
-## 2. 分角色：互不重叠的攻击面
+## 2. 配置成员与角色
 
-每个 pane 领一个**方法论上互斥**的职责：`auditor` 审源码、`replicator` 复算数据、`adversary` 攻方法学。具体措辞是 `models.json` 里各自的 `charter`，改职责改那里。
+名单在同目录的 `models.json`。三个逻辑成员必须来自不同模型厂商，并显式使用各自的 `model`；不能依赖父会话或环境默认模型。启动后核对并在本轮记录中写下每个任务实际生效的模型；无法确认、与名单不符或三个成员落到同一厂商时，本轮无效。
 
-## 3. 交底与通信
+三个成员使用相同的中性只读执行约束，方法角色由每轮任务动态赋予：
 
-herdr 没有邮箱，只有 `agent prompt`（往别人输入框塞文字）和 `agent read`（把别人屏幕刮下来）。拓扑是星型，管理者是唯一的路由：跨 pane 的话全部由管理者转述，把 A 的原话引进 B 的下一条 prompt（「opus 说你这个计数可能一对多，用数据回应」）。
+- `auditor`：审源码、规范和提交，只接受可定位的直接证据。
+- `replicator`：绕开管理者的脚本和口径，从原始数据独立复算。
+- `adversary`：攻击前提和方法学，查样本敏感性、一对多计数和阴性对照。
 
-```
-                  管理者（本会话）
-              唯一写 FINDINGS 的人
-                │      │      │
-   下行：消息  │      │      │   herdr agent prompt
-   （短指针）  ▼      ▼      ▼
-              ┌────┐ ┌──────┐ ┌──────┐
-              │ sol│ │ grok │ │ opus │   彼此不相连
-              └──┬──┘ └──┬───┘ └──┬───┘
-                 │        │        │
-   上行：文件     └───────┴───────┘
-                          ▼
-              /tmp/<轮次>-<name>.md ← 管理者从磁盘读
-```
+模型与角色不得永久绑定。首轮可以按 `models.json` 顺序分配三个角色；后续根据争议轮换或交叉复核，使模型差异和角色差异能够被区分。每轮在 `rounds/N.md` 写明成员、模型、角色、输入文件和攻击点。
 
-技术上任何 pane 都能 prompt 任何 pane，让它们直连有四个代价：管理者看不见这次交换，ledger 就缺一环；对正在 working 的 agent 发 prompt 会被拒（`agent_blocked`）或插进它当前那一轮；没有投递回执；而且两两串供会让它们彼此收敛，恰好毁掉跨厂商独立性这唯一的价值来源。
+## 3. 交底与通信
 
-下行只发短指针，正文留在文件里：长文本经终端会被折断或触发意外快捷键。上行走文件：队员把结论写 `/tmp/<轮次>-<name>.md`，终端只回一行路径，管理者从磁盘读。`agent read` 是终端截图，会截断、会按宽度折行、会混进 TUI 边框，拿它收长输出必丢内容；只用它确认回执和状态。
+拓扑是星型，管理者是唯一消息路由。成员在同一轮中独立作答，在提交前不得看到其他成员本轮答案。需要逻辑成员 A 反驳逻辑成员 B 的上一轮结论时，由管理者在新任务中引用 B 的原话和证据位置；不能假定新实例记得上一轮聊天。
 
-基准文档 `FINDINGS-stageN.md` 是**唯一事实源**，只有管理者写，新版本整体取代旧版本而不是打补丁。必含四块：机制链、编号发现、已推翻清单、未闭合点。
-
-```bash
-MSG='【N17】读 /tmp/FINDINGS-stage4.md 全文。本轮你的攻击点：……。结论写 /tmp/N17-<你的名字>.md，终端只回一行路径。'
-for a in sol grok opus; do herdr agent prompt "$a" "$MSG"; done
-for a in sol grok opus; do herdr agent wait "$a" --until idle --timeout 900000; done
-```
+下行只给短任务和文件指针：每个成员阅读 `BRIEF.md`、最新 `FINDINGS-stageN.md`、`LEDGER.md` 和本轮文件。不得要求它重新梳理已经确认的全部背景。上行结果必须能归属到轮次和成员，并包含证据位置；长结果写入持久文件，不能依赖截断的终端文本。
 
 ## 4. 回合
 
-一轮 = 广播 → 各自独立干 → 管理者从磁盘收文件 → 裁决 → 更新文档 → 再广播。
+一轮 = 记录受保护文件和工作树初始状态 → 写本轮任务 → 三个成员并发独立调查 → 管理者收齐结果 → 检查子代理未修改项目或权威文件 → 核验证据并裁决 → 更新 FINDINGS 和 LEDGER → 决定下一轮。
 
-每轮广播里给每个 pane 一个**具体到能证伪的攻击点**（「查 ART 的 adbconnection.cc，确认这条错误日志与被销毁的 fd 是不是 1:1」），而不是「你看看有没有问题」。
+每个成员必须收到具体到能证伪的攻击点，例如“查 `adbconnection.cc`，确认该错误日志与被销毁的 fd 是否 1:1”，而不是“看看有没有问题”。子代理结束后即可释放；下一轮通过调查档案恢复事实状态，并重新创建独立任务。
 
 ## 5. 纪律
 
-- **ledger**：发现按 `N1, N2…` 只增不改；每一条被推翻的结论进 `X1, X2…` 清单，写明是谁推翻的。这份 X 清单是最终交付里最有价值的部分。
-- **retraction 要公开**：管理者被驳倒时，在下一次广播开头显式写「我错了，更正为……」。管理者一旦开始维护自己的结论，pane 就会停止攻击，整个队伍塌成回音室。
-- **replication**：任何承载结论的数字至少两方独立算。对不上先查口径再查代码。
-- **control**：任何「异常」指标必须配阴性样本才进文档。拿不出对照的指标只是一个数。
-- **grading**：每条结论标注 `源码读取 / 实测 / 推断` 和置信度。推断不能和实测并列陈述。
-- **裁决**：两个 pane 冲突时判出谁对，并说明依据。把冲突的结论平均掉会同时丢掉两边的信息。
+- **独立性**：同轮答案不得互相可见；成员之间不直接通信。
+- **只读完整性**：只读是协议约束，不假定执行环境构成沙箱。每轮结束后比较初始状态；发现子代理修改项目或权威文件时，该成员结果无效并显式报告污染范围。
+- **retraction**：管理者被驳倒时，在下一轮开头明确写“我错了，更正为……”，并追加对应 X。
+- **replication**：任何承载结论的数字至少由两个不同模型独立计算；对不上先查口径再查代码。
+- **control**：任何“异常”指标必须配阴性样本才进入 FINDINGS。
+- **grading**：每条结论标注 `源码读取 / 实测 / 推断` 和置信度；推断不能与实测并列陈述。
+- **裁决**：成员冲突时管理者必须判定谁对并说明证据，不能多数投票或折中平均。
+- **缺席视角**：成员失败或额度耗尽时，明确记录缺失的模型和方法角色，不能把不完整轮次当成完整评审。
 
 ## 6. 收尾
 
-收敛判据：完整一轮广播后没有任何 pane 能产出新的 X。
-
-最终文档必须单列**未闭合点**，以及**每一个需要人或设备批准才能执行的动作**。
-
-用完 `herdr pane close <pane_id>` 关掉，pane 不会自己退出。
-
-## 故障
-
-- pane 额度耗尽：降级为剩余 pane 继续，并在文档里记下缺失的是哪个视角。
-- agent 卡在 blocked：`herdr agent read <name> --source visible` 看它在等什么，多半是在等一个确认。
-- 广播后无人响应：`herdr agent list` 核对 pane 是否还活着，pane id 会随布局变化。
+收尾前必须进行一轮**开放攻击**：三个方法角色各自选择其认为最强的攻击点，不能只回答管理者预设的窄问题。只有完整开放攻击轮没有产生任何被管理者接受并记入 X 的新反证时才算收敛。最终文档单列未闭合点、缺失视角，以及每一个需要人或设备批准才能执行的动作。

package/skills/agent-team/models.json

@@ -1,25 +1,32 @@
 {
-  "defaults": {
-    "kind": "pi",
-    "thinking": "high"
-  },
   "members": [
     {
       "name": "sol",
-      "model": "pudu/gpt-5.6-sol",
-      "role": "auditor",
-      "charter": "只接受能逐行引用的源码、规范、commit，输出必须带 文件:行号。负责把「机制上可能」变成「代码里确实如此」；查不到就说查不到，不要用常识补。"
+      "vendor": "OpenAI",
+      "model": "pudu/gpt-5.6-sol"
     },
     {
       "name": "grok",
-      "model": "pudu/grok-4.6",
-      "role": "replicator",
-      "charter": "拿原始数据和口径，不看管理者的脚本，独立重算同一个指标，只报自己的数和差异。数对不上就是一次发现，先查口径再查代码。"
+      "vendor": "xAI",
+      "model": "pudu/grok-4.6"
     },
     {
       "name": "opus",
-      "model": "pudu/claude-opus-5",
-      "role": "adversary",
+      "vendor": "Anthropic",
+      "model": "pudu/claude-opus-5"
+    }
+  ],
+  "roles": [
+    {
+      "name": "auditor",
+      "charter": "只接受能逐行引用的源码、规范、commit，输出必须带文件和行号。负责把“机制上可能”变成“代码里确实如此”；查不到就说查不到，不要用常识补。"
+    },
+    {
+      "name": "replicator",
+      "charter": "拿原始数据和口径，不看管理者的脚本，独立重算同一个指标，只报自己的数和差异。数对不上就是一次发现，先查口径再查代码。"
+    },
+    {
+      "name": "adversary",
       "charter": "攻前提和方法学，不攻结论。指出指标对样本组成的敏感性、计数的一对多、缺失的阴性对照。附议没有价值，找不到问题就说明理由。"
     }
   ]

package/packages/todo/CHANGELOG.md

@@ -1,9 +0,0 @@
-# Changelog
-
-## Unreleased
-
-- replace generic Todo CRUD with serialized execution-plan lifecycle commands, guarded single-step advancement, preserved replan history, canonical current-plan results, branch reconstruction tests, and a live rerendering current-plan widget
-
-## 2026-09-30 - v0.1.0
-
-- 从 `@maxiaochao/pi-toolkit` 提取 todo 权威源码，支持主包捆绑和独立安装。