pi-ptc-subagents 7.2.0 → 7.3.0

package/dist/index.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, s
 import { join } from "node:path";
 import { execSync, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { mkdir, open, readFile, rename, writeFile } from "node:fs/promises";
+import { mkdir, open, readFile, readdir, rename, writeFile } from "node:fs/promises";
 import { gunzipSync, gzip } from "node:zlib";
 import { promisify } from "node:util";
 import { fileURLToPath } from "node:url";
@@ -2746,6 +2746,15 @@ const TERMINAL_STATUSES = [
 	"canceled",
 	"lost"
 ];
+const TASK_STATUSES = [
+	"queued",
+	"running",
+	"stopping",
+	"succeeded",
+	"failed",
+	"canceled",
+	"lost"
+];
 function isTerminal(status) {
 	return TERMINAL_STATUSES.includes(status);
 }
@@ -3341,6 +3350,47 @@ var NotificationCenter = class {
 function isTerminalStatus(status) {
 	return status === "succeeded" || status === "failed" || status === "canceled" || status === "lost";
 }
+/** 护栏的检查间隔（秒级问一次就够——阈值本身是分钟量级） */
+const STALL_CHECK_INTERVAL_MS = 1e3;
+var ChildActivityTracker = class {
+	#buffer = "";
+	#lastActivityAt;
+	/** 在飞的工具调用计数（嵌套调用靠计数，不靠集合——start/end 成对进出） */
+	#toolOpen = 0;
+	#now;
+	constructor(now = Date.now) {
+		this.#now = now;
+		this.#lastActivityAt = now();
+	}
+	/** 喂一段 stdout 增量（chunk 边界不按行切 ⇒ 自己攒半行） */
+	push(chunk) {
+		this.#lastActivityAt = this.#now();
+		this.#buffer += chunk;
+		let index = this.#buffer.indexOf("\n");
+		while (index >= 0) {
+			this.#consume(this.#buffer.slice(0, index));
+			this.#buffer = this.#buffer.slice(index + 1);
+			index = this.#buffer.indexOf("\n");
+		}
+	}
+	/** 两条都成立 ⇒ 孩子什么都没在做 */
+	isStalled(now, thresholdMs) {
+		if (this.#toolOpen > 0) return false;
+		return now - this.#lastActivityAt >= thresholdMs;
+	}
+	#consume(line) {
+		const trimmed = line.trim();
+		if (!trimmed.includes("\"tool_execution_start\"") && !trimmed.includes("\"tool_execution_end\"")) return;
+		let event;
+		try {
+			event = JSON.parse(trimmed);
+		} catch {
+			return;
+		}
+		if (event.type === "tool_execution_start") this.#toolOpen++;
+		else if (event.type === "tool_execution_end") this.#toolOpen = Math.max(0, this.#toolOpen - 1);
+	}
+};
 // ../dispatch/src/engine.ts
 const DEFAULT_STOP_GRACE_MS = 5e3;
 const STDOUT_KEEP_CHARS = 16777216;
@@ -3382,6 +3432,7 @@ var TaskEngine = class {
 	#terminalRecordKeep;
 	#archiveEnabled;
 	#archiveTtlDays;
+	#stallMs;
 	#purgeTail = Promise.resolve();
 	#children = /* @__PURE__ */ new Map();
 	#ending = false;
@@ -3404,6 +3455,7 @@ var TaskEngine = class {
 		this.#terminalRecordKeep = options.terminalRecordKeep ?? DEFAULT_TERMINAL_RECORD_KEEP;
 		this.#archiveEnabled = options.archiveEnabled ?? true;
 		this.#archiveTtlDays = options.archiveTtlDays ?? DEFAULT_ARCHIVE_TTL_DAYS;
+		this.#stallMs = options.stallMs ?? 3e5;
 		this.#ready = options.storageDir ? this.#restore(options.storageDir) : Promise.resolve();
 		this.#stopGraceMs = options.stopGraceMs ?? DEFAULT_STOP_GRACE_MS;
 		const whyOpt = options.whyEnabled;
@@ -3443,7 +3495,8 @@ var TaskEngine = class {
 				label: input.label,
 				whySuppressed,
 				ownerPid: this.#owner.pid,
-				ownerBootMs: this.#owner.bootMs
+				ownerBootMs: this.#owner.bootMs,
+				sessionId: this.#context.sessionId
 			}
 		}).then(async () => {
 			if (input.wait) {
@@ -3539,9 +3592,16 @@ var TaskEngine = class {
 			this.stop(taskId, `timeout after ${timeoutMs}ms`);
 		}, timeoutMs) : void 0;
 		timer?.unref();
+		const activity = new ChildActivityTracker();
+		const stallMs = this.#stallMs > 0 ? this.#stallMs : void 0;
+		const stallGuard = stallMs ? setInterval(() => {
+			if (activity.isStalled(Date.now(), stallMs)) this.stop(taskId, `stalled: no activity for ${stallMs}ms`);
+		}, Math.min(STALL_CHECK_INTERVAL_MS, stallMs)) : void 0;
+		stallGuard?.unref();
 		let text = "";
 		let outputTruncated = false;
 		child.onOutput((chunk) => {
+			activity.push(chunk);
 			text += chunk;
 			if (text.length > STDOUT_KEEP_CHARS) {
 				text = text.slice(-16777216);
@@ -3552,6 +3612,7 @@ var TaskEngine = class {
 			child.onExit((code) => resolveExit(code));
 		});
 		if (timer) clearTimeout(timer);
+		if (stallGuard) clearInterval(stallGuard);
 		this.#children.delete(taskId);
 		const outputPath = await this.#output.write(taskId, text);
 		const parsed = parseChildStream(text);
@@ -3700,6 +3761,23 @@ var TaskEngine = class {
 			return Promise.resolve(void 0);
 		}
 	}
+	/** 归档区的全部记录（冷存按 id 存 gz）——scope=all 时一次列出；异步读，不堵宿主事件循环 */
+	async readArchivedRecords() {
+		const dir = this.#storageDir ? join(this.#storageDir, "archive") : null;
+		if (!dir || !existsSync(dir)) return [];
+		const out = [];
+		for (const file of await readdir(dir)) {
+			if (!file.endsWith(".json.gz")) continue;
+			try {
+				const parsed = JSON.parse(gunzipSync(await readFile(join(dir, file))).toString("utf8"));
+				if (parsed && typeof parsed.id === "string") out.push({
+					...parsed,
+					archived: true
+				});
+			} catch {}
+		}
+		return out;
+	}
 	#readArchivedOutput(taskId) {
 		const file = this.#storageDir ? join(this.#storageDir, "archive", `${taskId}.output.gz`) : null;
 		if (!file || !existsSync(file)) return void 0;
@@ -3826,6 +3904,362 @@ var TaskEngine = class {
 		await this.#purgeTail.catch(() => void 0);
 	}
 };
+// ../tui/src/bounds.ts
+const RENDER_BOUNDS$1 = {
+	MAX_LOG_LINES_EXPANDED: 12,
+	VALUE_TREE_MAX_DEPTH: 4,
+	VALUE_TREE_MAX_CHILDREN: 6,
+	VALUE_TREE_MAX_LINE_CHARS: 120
+};
+// ../tui/src/text.ts
+const ANSI_PATTERN$1 = /\x1B\[[0-9:;<=>?]*[ -/]*[@-~]|\x1B\][^\x07\x1B]*(?:\x07|\x1B\\)|[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g;
+function stripAnsi$1(text) {
+	return text.replace(ANSI_PATTERN$1, "");
+}
+function sanitizeText$1(text) {
+	return stripAnsi$1(text.replace(/\r/g, ""));
+}
+const MAX_LINE_CHARS$1 = RENDER_BOUNDS$1.VALUE_TREE_MAX_LINE_CHARS;
+function truncateLine$1(line, maxChars = MAX_LINE_CHARS$1) {
+	if (line.length <= maxChars) return line;
+	let cut = maxChars;
+	while (cut > 0 && (line.charCodeAt(cut) & 64512) === 56320) cut--;
+	return `${line.slice(0, cut)}…`;
+}
+// ../tui/src/truncate.ts
+const TRUNCATION_MAX_BYTES$1 = 51200;
+const TMP_FILE_TTL_MS$1 = 864e5;
+const TMP_FILE_PREFIX$1 = "pi-ptc-output-";
+let sweptTmp$1 = false;
+function sweepExpiredTmp$1() {
+	sweptTmp$1 = true;
+	let names;
+	try {
+		names = readdirSync(tmpdir());
+	} catch {
+		return;
+	}
+	for (const name of names) {
+		if (!name.startsWith(TMP_FILE_PREFIX$1)) continue;
+		try {
+			const file = join(tmpdir(), name);
+			if (Date.now() - statSync(file).mtimeMs > TMP_FILE_TTL_MS$1) rmSync(file, { force: true });
+		} catch {}
+	}
+}
+function applyAdr0015Truncation$1(text) {
+	const lines = text.split("\n");
+	const bytes = Buffer.byteLength(text, "utf8");
+	if (bytes <= 51200 && lines.length <= 2e3) return {
+		text,
+		truncated: false
+	};
+	let keptLines = lines.slice(-2e3);
+	let kept = keptLines.join("\n");
+	while (Buffer.byteLength(kept, "utf8") > 51200 && keptLines.length > 1) {
+		keptLines = keptLines.slice(Math.max(1, Math.floor(keptLines.length / 2)));
+		kept = keptLines.join("\n");
+	}
+	const keptBuffer = Buffer.from(kept, "utf8");
+	if (keptBuffer.length > 51200) kept = keptBuffer.subarray(keptBuffer.length - TRUNCATION_MAX_BYTES$1).toString("utf8");
+	const fullOutputPath = join(tmpdir(), `${TMP_FILE_PREFIX$1}${randomUUID()}.txt`);
+	mkdirSync(tmpdir(), { recursive: true });
+	writeFileSync(fullOutputPath, text, "utf8");
+	if (!sweptTmp$1) sweepExpiredTmp$1();
+	return {
+		text: [`…（已截断：省略前 ${lines.length - keptLines.length} 行 / ${bytes - Buffer.byteLength(kept, "utf8")} 字节，全文在 ${fullOutputPath}）`, kept].join("\n"),
+		truncated: true,
+		fullOutputPath
+	};
+}
+// ../task/src/list-tasks.ts
+function selectVisibleTasks(records, recentCompletedLimit = 10) {
+	const inFlight = records.filter((record) => !isTerminal(record.status));
+	const recentCompleted = records.filter((record) => isTerminal(record.status)).sort((a, b) => (b.finishedAt ?? 0) - (a.finishedAt ?? 0)).slice(0, recentCompletedLimit);
+	return [...inFlight, ...recentCompleted];
+}
+function taskFaceVisible(records) {
+	return records.length > 0;
+}
+const TASK_TEXT_MAX_CHARS = 80;
+const SUMMARY_MAX_CHARS = 100;
+const LABEL_MAX_CHARS = 120;
+function projectTaskEntry(record, options = {}) {
+	return {
+		id: record.id,
+		status: record.status,
+		...record.label ? { label: truncateLine$1(record.label, LABEL_MAX_CHARS) } : {},
+		...record.finishedAt !== void 0 ? { finishedAt: record.finishedAt } : {},
+		...record.task ? { task: truncateLine$1(record.task, TASK_TEXT_MAX_CHARS) } : {},
+		...record.report?.summary ? { summary: truncateLine$1(record.report.summary, SUMMARY_MAX_CHARS) } : {},
+		...options.archived ? { archived: true } : {},
+		...options.withSession && record.sessionId ? { sessionId: record.sessionId } : {}
+	};
+}
+function fitTaskEntries(entries, limit) {
+	const picked = [];
+	let bytes = 2;
+	for (const entry of entries) {
+		if (picked.length >= limit) break;
+		const size = Buffer.byteLength(JSON.stringify(entry), "utf8") + 1;
+		if (bytes + size > 49152) break;
+		picked.push(entry);
+		bytes += size;
+	}
+	return picked;
+}
+// ../routes/src/surface.ts
+const FALLBACK_SURFACE_MODE = "full_ptc";
+// ../routes/src/registry.ts
+const TOOLS = {
+	ptc_run_code: {
+		name: "ptc_run_code",
+		description: (s) => ["写一段 TypeScript 程序批量调用工具：tools.<name>(args)。支持顶层 await、Promise.all 并行、循环与条件；程序返回值是归约后的结果，中间产物不进上下文。", s === "codemode_ptc" ? "本会话里我从 codemode 脚本可达，模型直走 codemode。" : [
+			"什么时候写程序而不是逐个调工具，看系统提示词 <ptc> 节的路由表。",
+			"程序内可调本会话已启用的同名工具（read / write / edit / grep / find / ls；bash 默认不可用），参数与直接调用该工具完全一致；每次调用返回 Promise，要 await，返回文本结果，失败抛异常。",
+			"程序内还可调 task_records({ scope: \"all\" }) 取任务记录（all 含压缩归档）——要挑很多条时在程序里筛完只 return 要的几条。",
+			"例：const files = await tools.find({ pattern: \"*.py\" }); for (const f of files) await tools.write({ path: f, content: body });"
+		].join("")].join("")
+	},
+	ptc_workflow: {
+		name: "ptc_workflow",
+		description: (s) => ["结构化的多阶段程序：script 里可用 workflow.log / workflow.phase / workflow.parallel / workflow.pipeline。适合阶段明确的批处理。", s === "codemode_ptc" ? "本会话里我从 codemode 脚本可达。" : "与 ptc_run_code 的取舍看 <ptc> 节的路由表。"].join("")
+	},
+	pi_task_codemode: {
+		name: "pi_task_codemode",
+		description: () => "建一条子代理任务，默认立刻返回 handle（taskId + label）；wait:true 时阻塞到终态再返回结果。任务在任务记录里排队，由派发引擎起独立 pi 进程执行；完成后的报告与产出经 ptc_task_output 读取。"
+	},
+	ptc_task_list: {
+		name: "ptc_task_list",
+		description: () => "列出在飞的任务与最近完成的任务（默认最近 50 条已完成）。响应给精简条目（id/status/label/finishedAt/任务摘要）与候选总数——总数比返回条数大，说明还有更早的记录没列出来。scope=all 连压缩归档一起列（更全也更慢），status 与 session 可筛。"
+	},
+	ptc_task_output: {
+		name: "ptc_task_output",
+		description: () => "按 task_id 读一条任务记录：状态、报告、孩子的正文（text——那是交付物，报告只是摘要）与实测轨迹。正文超长时按截断契约给尾部与全文路径；记录里的 outputPath 指向原始事件流。"
+	},
+	ptc_task_stop: {
+		name: "ptc_task_stop",
+		description: () => "按 task_id 叫停任务：排队中的直接抽掉（canceled），在跑的转 stopping。"
+	}
+};
+const TASK_DOOR_PARAM_DESCRIPTIONS = {
+	task: "孩子要干的活",
+	agent: "已注册的 agent 名字；省略 = 通用孩子",
+	agentScope: "agent 定义的查找范围（user / project / both）",
+	why: "这一刀为什么切出来（调用方自己的话）——它会进孩子的提示词、多花孩子的 token；孩子从 task 里已经能读懂就别传",
+	model: "覆盖孩子跑的模型",
+	thinkingLevel: "覆盖孩子的思考档位——孩子的思考 token 是可调的成本项",
+	wait: "true = 等这个任务完成再返回结果；false = 立刻返回 handle，结果走任务面/通知",
+	label: "后台任务给人看的标签",
+	readOnly: "strict = 孩子只有读工具（read/grep/find/ls，搜索开启时含 web_ds_search）；lenient = 默认全工具。只需要读的活别给写权限",
+	timeoutMs: "孩子的运行时长上限（毫秒）——超了按超时收尸；不传 = 不限（与不传时同）",
+	projectContext: "孩子的项目上下文（AGENTS.md/CLAUDE.md）：auto = 照常加载；none = 不加载——注意 none 只关「注入」不关「知识」：文件还在工作目录里，孩子会自己去翻（实测输入只差约 15%，不是省一半）；这活不需要项目约定就传 none，要孩子遵守项目规矩就照常传（auto 也可能把项目里的写码规矩套进答案）"
+};
+const DELIVERY_CHECK_LEAD = "交付核对（引擎实测）";
+const DELIVERY_CHECK_NOTHING = "这孩子的结论没有依据：重派它，或明说缺口，别替它补数。";
+/** 父面渲染一行交付核对：工具/路径（实测）· 报错 · 正文长度 · 报告条数（自述） */
+function renderDeliveryCheck(input) {
+	const d = input.delivery;
+	if (!d) return "";
+	const calls = Object.entries(d.tools);
+	const totalCalls = calls.reduce((sum, [, count]) => sum + count, 0);
+	const parts = [];
+	if (calls.length > 0) {
+		const tools = calls.map(([name, count]) => `${name}×${count}`).join(" ");
+		const paths = d.paths.length > 0 ? `（${d.paths.slice(0, 5).join("、")}${d.paths.length > 5 ? ` 等 ${d.paths.length} 条` : ""}）` : "";
+		parts.push(`工具 ${tools}${paths}`);
+	} else parts.push("没调用任何工具");
+	parts.push(`报错 ${d.errors}`);
+	parts.push(`正文 ${d.textChars} 字`);
+	const findings = input.findings ?? 0;
+	parts.push(`报告 ${findings} 条（${input.channel ?? "none"}）`);
+	return totalCalls === 0 && findings === 0 && d.textChars === 0 ? `${DELIVERY_CHECK_LEAD}：零产出——${parts.join(" · ")}。${DELIVERY_CHECK_NOTHING}` : `${DELIVERY_CHECK_LEAD}：${parts.join(" · ")}`;
+}
+const ROUTES = [
+	{
+		id: "create-a-task",
+		name: "派一个子代理",
+		when: "材料多、主题互不相干、每份都要读一堆材料时派——父一个人扛会算错（实测 92%→100%，n=3）；成本 10 倍上下，一件能算完的活别派",
+		how: {
+			full_ptc: "tools.pi_task_ptc({ task, label? })（程序内）——task 是孩子的唯一规格（写死路径/命令/交付物格式）；要报告就点名 child report 的 JSON 块（summary/findings），别自创报告格式；汇总前核对孩子产出（delivery），零产出就重派别补数",
+			codemode_ptc: "tools.pi_task_codemode({ task, label? })（脚本内）——task 是孩子的唯一规格（写死路径/命令/交付物格式）；要报告就点名 child report 的 JSON 块（summary/findings），别自创报告格式；汇总前核对孩子产出（delivery），零产出就重派别补数"
+		},
+		fact: "默认不等，立刻返回 handle；任务在任务记录里排队，可经任务面三工具查/停",
+		detail: "docs/routes/create-a-task.md"
+	},
+	{
+		id: "run-one-program",
+		name: "批量调工具的一段程序",
+		when: "连续多次工具调用、结果要过滤/归约后再看",
+		how: {
+			full_ptc: "ptc_run_code({ code, description })",
+			codemode_ptc: "不适用——写程序是 full_ptc 面的编排能力；本面用 codemode 编排、pi_task_codemode 派任务"
+		},
+		fact: "程序内 tools.*；bash 当前不在程序绑定表里（旧 ADR-0040 的 opt-in 尚未接线）；只在本面（full_ptc）注册 PTC 工具",
+		detail: "docs/routes/run-one-program.md"
+	},
+	{
+		id: "run-a-phased-workflow",
+		name: "分阶段 workflow",
+		when: "批处理有明确阶段，要阶段性可见进度",
+		how: {
+			full_ptc: "ptc_workflow({ meta, script, args? })",
+			codemode_ptc: "不适用——同 run-one-program：workflow 是 full_ptc 的编排能力"
+		},
+		fact: "script 内可用 workflow.log/phase/parallel/pipeline；只在本面注册",
+		detail: "docs/routes/run-a-phased-workflow.md"
+	},
+	{
+		id: "use-the-built-in-tools",
+		name: "直接用内置工具",
+		when: "单次调用就够，或每步都要模型判断（写操作、审批敏感）",
+		how: {
+			full_ptc: "程序内 tools.read/grep/find/ls/edit/write；逐个直调走 pi 自己的工具",
+			codemode_ptc: "脚本内 tools.<内置名> 直接调"
+		},
+		fact: "bash 当前不在程序绑定表里（旧 ADR-0040 的 opt-in 尚未接线）",
+		detail: "docs/routes/use-the-built-in-tools.md"
+	},
+	{
+		id: "report-what-you-did",
+		name: "交报告",
+		when: "子代理收工：结论要有证据、副作用与用量要可核对",
+		how: {
+			full_ptc: "孩子的契约：最终消息末尾 fenced JSON（summary/findings/files_touched/usage）；宿主自动解析",
+			codemode_ptc: "同左——契约在孩子的追加提示词里，与 surface 无关"
+		},
+		fact: "reportChannel 恒在四值：tool/prompt-json/none/opted-out；工具通道（ptc_child_report）已是首选",
+		detail: "docs/routes/report-what-you-did.md"
+	},
+	{
+		id: "reach-the-web",
+		name: "上网查资料",
+		when: "需要网页搜索、抓页面、页内找内容——判断力在干活的子代理侧",
+		how: {
+			full_ptc: "派子代理（pi_task_ptc），孩子用 web_ds_search（search/open/find 三动作）",
+			codemode_ptc: "同左——搜索只在子代理进程里注册，父会话没有这个工具"
+		},
+		fact: "webDsSearch 开关默认关（fail-closed）；配额每进程计；概览走 snippet 超预算整条丢弃",
+		detail: "docs/routes/reach-the-web.md"
+	},
+	{
+		id: "manage-a-task",
+		name: "管一个任务",
+		when: "要知道孩子跑得怎样、读它的产出、或叫停它",
+		how: {
+			full_ptc: "ptc_task_list / ptc_task_output / ptc_task_stop（模型直调）——产出里的 delivery 是引擎实测轨迹",
+			codemode_ptc: "同左（模型直调；脚本经结构化返回）——产出里的 delivery 是引擎实测轨迹"
+		},
+		fact: "有任务记录这三个工具才出现在模型面前（ADR-0007）",
+		detail: "docs/routes/manage-a-task.md"
+	}
+];
+const LONG_OUTPUT_GUIDANCE_WITH_REPORT = "产出超过截断阈值（{bytes} 字节）。先看孩子的报告（归约层）：{report}——响应里的 output 是截断后的尾部；报告没收录的完整原文用 read 读记录上的 outputPath。";
+const LONG_OUTPUT_GUIDANCE_NO_REPORT = "产出超过截断阈值（{bytes} 字节），且孩子未交报告（reportChannel=none，散文可信度存疑）。响应里的 output 是截断后的尾部；完整原文用 read 读记录上的 outputPath。";
+function renderLongOutputGuidance(options) {
+	if (options.report && options.reportChannel && options.reportChannel !== "none") {
+		const findings = (options.report.findings ?? []).slice(0, 5).map((f) => `- ${f.what}${f.evidence ? `（证据：${f.evidence}）` : ""}`).join("\n");
+		return LONG_OUTPUT_GUIDANCE_WITH_REPORT.replace("{bytes}", String(options.bytes)).replace("{report}", [`summary: ${options.report.summary}`, findings].filter(Boolean).join("\n"));
+	}
+	return LONG_OUTPUT_GUIDANCE_NO_REPORT.replace("{bytes}", String(options.bytes));
+}
+const COMPACTED_TASK_REMINDER_LEAD = "对话刚被压缩——启动这些任务的消息已经不在上下文里了，但任务还在跑或已经跑完。用 ptc_task_list 看全部（scope=all 连压缩归档一起列），用 ptc_task_output 取产出（给的是孩子的正文，不是原始事件流）。";
+function renderCompactedTaskReminder(tasks) {
+	const lines = tasks.map((t) => `- ${t.id}${t.label ? ` (${t.label})` : ""}: ${t.status}`);
+	return [
+		"<compacted-tasks>",
+		COMPACTED_TASK_REMINDER_LEAD,
+		...lines,
+		"</compacted-tasks>"
+	].join("\n");
+}
+function renderTaskNotifications(batch) {
+	return [
+		"<bg-task-notifications>",
+		...batch.map((n) => `- task ${n.taskId}${n.label ? ` (${n.label})` : ""}: ${n.status}${n.stopReason ? ` — ${n.stopReason}` : ""}`),
+		"</bg-task-notifications>"
+	].join("\n");
+}
+function estimateTokens(text) {
+	return Math.ceil(text.length / 2);
+}
+const ROUTE_INDEX_LEAD = {
+	full_ptc: "批量调工具默认先写程序（ptc_run_code）；单次调用或要逐步判断、审批敏感的才直连。派不派子代理自己判断——路由表第一行写了代价。",
+	codemode_ptc: "编排写 codemode 脚本；批量派活经脚本内的 pi_task_codemode；要查/停任务用任务面三工具。派不派自己判断——路由表第一行写了代价。"
+};
+function renderRouteIndex(surface, detailBase, nudge = true) {
+	const lines = ROUTES.map((route) => `- ${route.name} — ${route.when}。这面怎么走：${route.how[surface]}。细节：${detailBase ? route.detail.split("/").pop() : route.detail}`);
+	let index = [
+		`<ptc>`,
+		...nudge ? [ROUTE_INDEX_LEAD[surface]] : [],
+		...detailBase ? [`详情目录：${detailBase}`] : [],
+		"路由表（一条一行，详情按需 read）：",
+		...lines,
+		`</ptc>`
+	].join("\n");
+	const tokens = estimateTokens(index);
+	if (tokens > 560) index += `\n> WARNING: index over token budget (${tokens} > 560); move detail into docs/routes/*.md`;
+	return index;
+}
+function taskListSnapshot(registry, query = {}, archived = []) {
+	const scope = query.scope === "all" ? "all" : "recent";
+	const limit = Math.min(Math.max(query.limit ?? 50, 1), 200);
+	const candidates = (scope === "all" ? [...registry.list(), ...archived] : registry.list()).filter((record) => {
+		if (query.status && record.status !== query.status) return false;
+		if (query.session && record.sessionId !== query.session) return false;
+		return true;
+	});
+	const visible = selectVisibleTasks(candidates, limit);
+	const withSession = query.session !== void 0;
+	return {
+		scope,
+		total: candidates.length,
+		tasks: fitTaskEntries(visible.map((record) => projectTaskEntry(record, {
+			archived: "archived" in record,
+			withSession
+		})), limit)
+	};
+}
+function faceVisible(registry) {
+	return taskFaceVisible(registry.list());
+}
+/**
+* 压缩后重注入的清单：在飞任务 + 最近完成的 5 条。
+* 没有任务就不注入（空清单只是噪音）。
+*/
+function compactedTaskReminder(registry) {
+	const records = registry.list();
+	const inFlight = records.filter((record) => !isTerminal(record.status));
+	const recentCompleted = records.filter((record) => isTerminal(record.status)).sort((a, b) => (b.finishedAt ?? 0) - (a.finishedAt ?? 0)).slice(0, 5);
+	if (inFlight.length === 0 && recentCompleted.length === 0) return void 0;
+	return renderCompactedTaskReminder([...inFlight, ...recentCompleted].map((record) => ({
+		id: record.id,
+		status: record.status,
+		label: record.label
+	})));
+}
+// ../task/src/output.ts
+/**
+* 任务产出读法：先给归约后的孩子正文（从事件流现算，不另存一份），
+* 没有正文才退回原始尾部 + 分层引导（完整原文在 outputPath）。
+*/
+async function readTaskOutput(source, record) {
+	const taskId = record.id;
+	const outputBytes = await source.outputSize(taskId);
+	if (outputBytes === void 0) return {};
+	const tail = await source.readOutputTail(taskId, 51200) ?? "";
+	let answer = parseChildStream(tail).text;
+	if (!answer && outputBytes > 51200) answer = parseChildStream(await source.readOutput(taskId) ?? "").text;
+	if (answer) return { text: applyAdr0015Truncation$1(answer).text };
+	return {
+		output: applyAdr0015Truncation$1(tail).text,
+		guidance: renderLongOutputGuidance({
+			bytes: outputBytes,
+			report: record.report,
+			reportChannel: record.reportChannel ?? "none"
+		})
+	};
+}
 // ../search/src/provider.ts
 const SEARCH_COUNT_RANGE = {
 	min: 1,
@@ -3982,102 +4416,40 @@ function createSearchMemory() {
 		while (entries.length > 5) {
 			const evicted = entries.shift();
 			if (!evicted) break;
-			totalChars -= evicted.chars;
-		}
-	};
-	return {
-		remember(query, matches) {
-			entries.push({
-				query,
-				matches,
-				textByUrl: /* @__PURE__ */ new Map(),
-				chars: query.length
-			});
-			trim();
-		},
-		storeText(url, text) {
-			for (let i = entries.length - 1; i >= 0; i--) {
-				const entry = entries[i];
-				const match = entry.matches.find((m) => urlsLooselyEqual(m.url, url));
-				if (!match) continue;
-				entry.textByUrl.set(match.url, text);
-				entry.chars += text.length;
-				totalChars += text.length;
-				trim();
-				return;
-			}
-			looseChars -= looseTexts.get(url)?.length ?? 0;
-			looseTexts.set(url, text);
-			looseChars += text.length;
-			totalChars += text.length;
-			trim();
-		},
-		lookup(url) {
-			for (let i = entries.length - 1; i >= 0; i--) for (const [stored, text] of entries[i].textByUrl) if (urlsLooselyEqual(stored, url)) return text;
-			for (const [stored, text] of [...looseTexts].reverse()) if (urlsLooselyEqual(stored, url)) return text;
-		}
-	};
-}
-// ../tui/src/bounds.ts
-const RENDER_BOUNDS$1 = {
-	MAX_LOG_LINES_EXPANDED: 12,
-	VALUE_TREE_MAX_DEPTH: 4,
-	VALUE_TREE_MAX_CHILDREN: 6,
-	VALUE_TREE_MAX_LINE_CHARS: 120
-};
-// ../tui/src/text.ts
-const ANSI_PATTERN$1 = /\x1B\[[0-9:;<=>?]*[ -/]*[@-~]|\x1B\][^\x07\x1B]*(?:\x07|\x1B\\)|[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g;
-function stripAnsi$1(text) {
-	return text.replace(ANSI_PATTERN$1, "");
-}
-function sanitizeText$1(text) {
-	return stripAnsi$1(text.replace(/\r/g, ""));
-}
-RENDER_BOUNDS$1.VALUE_TREE_MAX_LINE_CHARS;
-// ../tui/src/truncate.ts
-const TRUNCATION_MAX_BYTES$1 = 51200;
-const TMP_FILE_TTL_MS$1 = 864e5;
-const TMP_FILE_PREFIX$1 = "pi-ptc-output-";
-let sweptTmp$1 = false;
-function sweepExpiredTmp$1() {
-	sweptTmp$1 = true;
-	let names;
-	try {
-		names = readdirSync(tmpdir());
-	} catch {
-		return;
-	}
-	for (const name of names) {
-		if (!name.startsWith(TMP_FILE_PREFIX$1)) continue;
-		try {
-			const file = join(tmpdir(), name);
-			if (Date.now() - statSync(file).mtimeMs > TMP_FILE_TTL_MS$1) rmSync(file, { force: true });
-		} catch {}
-	}
-}
-function applyAdr0015Truncation$1(text) {
-	const lines = text.split("\n");
-	const bytes = Buffer.byteLength(text, "utf8");
-	if (bytes <= 51200 && lines.length <= 2e3) return {
-		text,
-		truncated: false
-	};
-	let keptLines = lines.slice(-2e3);
-	let kept = keptLines.join("\n");
-	while (Buffer.byteLength(kept, "utf8") > 51200 && keptLines.length > 1) {
-		keptLines = keptLines.slice(Math.max(1, Math.floor(keptLines.length / 2)));
-		kept = keptLines.join("\n");
-	}
-	const keptBuffer = Buffer.from(kept, "utf8");
-	if (keptBuffer.length > 51200) kept = keptBuffer.subarray(keptBuffer.length - TRUNCATION_MAX_BYTES$1).toString("utf8");
-	const fullOutputPath = join(tmpdir(), `${TMP_FILE_PREFIX$1}${randomUUID()}.txt`);
-	mkdirSync(tmpdir(), { recursive: true });
-	writeFileSync(fullOutputPath, text, "utf8");
-	if (!sweptTmp$1) sweepExpiredTmp$1();
+			totalChars -= evicted.chars;
+		}
+	};
 	return {
-		text: [`…（已截断：省略前 ${lines.length - keptLines.length} 行 / ${bytes - Buffer.byteLength(kept, "utf8")} 字节，全文在 ${fullOutputPath}）`, kept].join("\n"),
-		truncated: true,
-		fullOutputPath
+		remember(query, matches) {
+			entries.push({
+				query,
+				matches,
+				textByUrl: /* @__PURE__ */ new Map(),
+				chars: query.length
+			});
+			trim();
+		},
+		storeText(url, text) {
+			for (let i = entries.length - 1; i >= 0; i--) {
+				const entry = entries[i];
+				const match = entry.matches.find((m) => urlsLooselyEqual(m.url, url));
+				if (!match) continue;
+				entry.textByUrl.set(match.url, text);
+				entry.chars += text.length;
+				totalChars += text.length;
+				trim();
+				return;
+			}
+			looseChars -= looseTexts.get(url)?.length ?? 0;
+			looseTexts.set(url, text);
+			looseChars += text.length;
+			totalChars += text.length;
+			trim();
+		},
+		lookup(url) {
+			for (let i = entries.length - 1; i >= 0; i--) for (const [stored, text] of entries[i].textByUrl) if (urlsLooselyEqual(stored, url)) return text;
+			for (const [stored, text] of [...looseTexts].reverse()) if (urlsLooselyEqual(stored, url)) return text;
+		}
 	};
 }
 // ../search/src/run.ts
@@ -4279,188 +4651,6 @@ function createWebDsSearchTool(context) {
 		}
 	};
 }
-// ../routes/src/surface.ts
-const FALLBACK_SURFACE_MODE = "full_ptc";
-// ../routes/src/registry.ts
-const TOOLS = {
-	ptc_run_code: {
-		name: "ptc_run_code",
-		description: (s) => ["写一段 TypeScript 程序批量调用工具：tools.<name>(args)。支持顶层 await、Promise.all 并行、循环与条件；程序返回值是归约后的结果，中间产物不进上下文。", s === "codemode_ptc" ? "本会话里我从 codemode 脚本可达，模型直走 codemode。" : [
-			"什么时候写程序而不是逐个调工具，看系统提示词 <ptc> 节的路由表。",
-			"程序内可调本会话已启用的同名工具（read / write / edit / grep / find / ls；bash 默认不可用），参数与直接调用该工具完全一致；每次调用返回 Promise，要 await，返回文本结果，失败抛异常。",
-			"例：const files = await tools.find({ pattern: \"*.py\" }); for (const f of files) await tools.write({ path: f, content: body });"
-		].join("")].join("")
-	},
-	ptc_workflow: {
-		name: "ptc_workflow",
-		description: (s) => ["结构化的多阶段程序：script 里可用 workflow.log / workflow.phase / workflow.parallel / workflow.pipeline。适合阶段明确的批处理。", s === "codemode_ptc" ? "本会话里我从 codemode 脚本可达。" : "与 ptc_run_code 的取舍看 <ptc> 节的路由表。"].join("")
-	},
-	pi_task_codemode: {
-		name: "pi_task_codemode",
-		description: () => "建一条子代理任务，默认立刻返回 handle（taskId + label）；wait:true 时阻塞到终态再返回结果。任务在任务记录里排队，由派发引擎起独立 pi 进程执行；完成后的报告与产出经 ptc_task_output 读取。"
-	},
-	ptc_task_list: {
-		name: "ptc_task_list",
-		description: () => "列出在飞的任务与最近完成的任务（最近 10 条已完成）。"
-	},
-	ptc_task_output: {
-		name: "ptc_task_output",
-		description: () => "按 task_id 读一条任务记录：状态、报告、产出。产出超过截断阈值时给尾部与完整产出位置（outputPath）。"
-	},
-	ptc_task_stop: {
-		name: "ptc_task_stop",
-		description: () => "按 task_id 叫停任务：排队中的直接抽掉（canceled），在跑的转 stopping。"
-	}
-};
-const TASK_DOOR_PARAM_DESCRIPTIONS = {
-	task: "孩子要干的活",
-	agent: "已注册的 agent 名字；省略 = 通用孩子",
-	agentScope: "agent 定义的查找范围（user / project / both）",
-	why: "这一刀为什么切出来（调用方自己的话）——它会进孩子的提示词、多花孩子的 token；孩子从 task 里已经能读懂就别传",
-	model: "覆盖孩子跑的模型",
-	thinkingLevel: "覆盖孩子的思考档位——孩子的思考 token 是可调的成本项",
-	wait: "true = 等这个任务完成再返回结果；false = 立刻返回 handle，结果走任务面/通知",
-	label: "后台任务给人看的标签",
-	readOnly: "strict = 孩子只有读工具（read/grep/find/ls，搜索开启时含 web_ds_search）；lenient = 默认全工具。只需要读的活别给写权限",
-	timeoutMs: "孩子的运行时长上限（毫秒）——超了按超时收尸；不传 = 不限（与不传时同）",
-	projectContext: "孩子的项目上下文（AGENTS.md/CLAUDE.md）：auto = 照常加载；none = 不加载——注意 none 只关「注入」不关「知识」：文件还在工作目录里，孩子会自己去翻（实测输入只差约 15%，不是省一半）；这活不需要项目约定就传 none，要孩子遵守项目规矩就照常传（auto 也可能把项目里的写码规矩套进答案）"
-};
-const DELIVERY_CHECK_LEAD = "交付核对（引擎实测）";
-const DELIVERY_CHECK_NOTHING = "这孩子的结论没有依据：重派它，或明说缺口，别替它补数。";
-/** 父面渲染一行交付核对：工具/路径（实测）· 报错 · 正文长度 · 报告条数（自述） */
-function renderDeliveryCheck(input) {
-	const d = input.delivery;
-	if (!d) return "";
-	const calls = Object.entries(d.tools);
-	const totalCalls = calls.reduce((sum, [, count]) => sum + count, 0);
-	const parts = [];
-	if (calls.length > 0) {
-		const tools = calls.map(([name, count]) => `${name}×${count}`).join(" ");
-		const paths = d.paths.length > 0 ? `（${d.paths.slice(0, 5).join("、")}${d.paths.length > 5 ? ` 等 ${d.paths.length} 条` : ""}）` : "";
-		parts.push(`工具 ${tools}${paths}`);
-	} else parts.push("没调用任何工具");
-	parts.push(`报错 ${d.errors}`);
-	parts.push(`正文 ${d.textChars} 字`);
-	const findings = input.findings ?? 0;
-	parts.push(`报告 ${findings} 条（${input.channel ?? "none"}）`);
-	return totalCalls === 0 && findings === 0 && d.textChars === 0 ? `${DELIVERY_CHECK_LEAD}：零产出——${parts.join(" · ")}。${DELIVERY_CHECK_NOTHING}` : `${DELIVERY_CHECK_LEAD}：${parts.join(" · ")}`;
-}
-const ROUTES = [
-	{
-		id: "create-a-task",
-		name: "派一个子代理",
-		when: "材料多、主题互不相干、每份都要读一堆材料时派——父一个人扛会算错（实测 92%→100%，n=3）；成本 10 倍上下，一件能算完的活别派",
-		how: {
-			full_ptc: "tools.pi_task_ptc({ task, label? })（程序内）——task 是孩子的唯一规格（写死路径/命令/交付物格式）；要报告就点名 child report 的 JSON 块（summary/findings），别自创报告格式；汇总前核对孩子产出（delivery），零产出就重派别补数",
-			codemode_ptc: "tools.pi_task_codemode({ task, label? })（脚本内）——task 是孩子的唯一规格（写死路径/命令/交付物格式）；要报告就点名 child report 的 JSON 块（summary/findings），别自创报告格式；汇总前核对孩子产出（delivery），零产出就重派别补数"
-		},
-		fact: "默认不等，立刻返回 handle；任务在任务记录里排队，可经任务面三工具查/停",
-		detail: "docs/routes/create-a-task.md"
-	},
-	{
-		id: "run-one-program",
-		name: "批量调工具的一段程序",
-		when: "连续多次工具调用、结果要过滤/归约后再看",
-		how: {
-			full_ptc: "ptc_run_code({ code, description })",
-			codemode_ptc: "不适用——写程序是 full_ptc 面的编排能力；本面用 codemode 编排、pi_task_codemode 派任务"
-		},
-		fact: "程序内 tools.*；bash 当前不在程序绑定表里（旧 ADR-0040 的 opt-in 尚未接线）；只在本面（full_ptc）注册 PTC 工具",
-		detail: "docs/routes/run-one-program.md"
-	},
-	{
-		id: "run-a-phased-workflow",
-		name: "分阶段 workflow",
-		when: "批处理有明确阶段，要阶段性可见进度",
-		how: {
-			full_ptc: "ptc_workflow({ meta, script, args? })",
-			codemode_ptc: "不适用——同 run-one-program：workflow 是 full_ptc 的编排能力"
-		},
-		fact: "script 内可用 workflow.log/phase/parallel/pipeline；只在本面注册",
-		detail: "docs/routes/run-a-phased-workflow.md"
-	},
-	{
-		id: "use-the-built-in-tools",
-		name: "直接用内置工具",
-		when: "单次调用就够，或每步都要模型判断（写操作、审批敏感）",
-		how: {
-			full_ptc: "程序内 tools.read/grep/find/ls/edit/write；逐个直调走 pi 自己的工具",
-			codemode_ptc: "脚本内 tools.<内置名> 直接调"
-		},
-		fact: "bash 当前不在程序绑定表里（旧 ADR-0040 的 opt-in 尚未接线）",
-		detail: "docs/routes/use-the-built-in-tools.md"
-	},
-	{
-		id: "report-what-you-did",
-		name: "交报告",
-		when: "子代理收工：结论要有证据、副作用与用量要可核对",
-		how: {
-			full_ptc: "孩子的契约：最终消息末尾 fenced JSON（summary/findings/files_touched/usage）；宿主自动解析",
-			codemode_ptc: "同左——契约在孩子的追加提示词里，与 surface 无关"
-		},
-		fact: "reportChannel 恒在四值：tool/prompt-json/none/opted-out；工具通道（ptc_child_report）已是首选",
-		detail: "docs/routes/report-what-you-did.md"
-	},
-	{
-		id: "reach-the-web",
-		name: "上网查资料",
-		when: "需要网页搜索、抓页面、页内找内容——判断力在干活的子代理侧",
-		how: {
-			full_ptc: "派子代理（pi_task_ptc），孩子用 web_ds_search（search/open/find 三动作）",
-			codemode_ptc: "同左——搜索只在子代理进程里注册，父会话没有这个工具"
-		},
-		fact: "webDsSearch 开关默认关（fail-closed）；配额每进程计；概览走 snippet 超预算整条丢弃",
-		detail: "docs/routes/reach-the-web.md"
-	},
-	{
-		id: "manage-a-task",
-		name: "管一个任务",
-		when: "要知道孩子跑得怎样、读它的产出、或叫停它",
-		how: {
-			full_ptc: "ptc_task_list / ptc_task_output / ptc_task_stop（模型直调）——产出里的 delivery 是引擎实测轨迹",
-			codemode_ptc: "同左（模型直调；脚本经结构化返回）——产出里的 delivery 是引擎实测轨迹"
-		},
-		fact: "有任务记录这三个工具才出现在模型面前（ADR-0007）",
-		detail: "docs/routes/manage-a-task.md"
-	}
-];
-const LONG_OUTPUT_GUIDANCE_WITH_REPORT = "产出超过截断阈值（{bytes} 字节）。先看孩子的报告（归约层）：{report}——响应里的 output 是截断后的尾部；报告没收录的完整原文用 read 读记录上的 outputPath。";
-const LONG_OUTPUT_GUIDANCE_NO_REPORT = "产出超过截断阈值（{bytes} 字节），且孩子未交报告（reportChannel=none，散文可信度存疑）。响应里的 output 是截断后的尾部；完整原文用 read 读记录上的 outputPath。";
-function renderLongOutputGuidance(options) {
-	if (options.report && options.reportChannel && options.reportChannel !== "none") {
-		const findings = (options.report.findings ?? []).slice(0, 5).map((f) => `- ${f.what}${f.evidence ? `（证据：${f.evidence}）` : ""}`).join("\n");
-		return LONG_OUTPUT_GUIDANCE_WITH_REPORT.replace("{bytes}", String(options.bytes)).replace("{report}", [`summary: ${options.report.summary}`, findings].filter(Boolean).join("\n"));
-	}
-	return LONG_OUTPUT_GUIDANCE_NO_REPORT.replace("{bytes}", String(options.bytes));
-}
-function renderTaskNotifications(batch) {
-	return [
-		"<bg-task-notifications>",
-		...batch.map((n) => `- task ${n.taskId}${n.label ? ` (${n.label})` : ""}: ${n.status}${n.stopReason ? ` — ${n.stopReason}` : ""}`),
-		"</bg-task-notifications>"
-	].join("\n");
-}
-function estimateTokens(text) {
-	return Math.ceil(text.length / 2);
-}
-const ROUTE_INDEX_LEAD = {
-	full_ptc: "批量调工具默认先写程序（ptc_run_code）；单次调用或要逐步判断、审批敏感的才直连。派不派子代理自己判断——路由表第一行写了代价。",
-	codemode_ptc: "编排写 codemode 脚本；批量派活经脚本内的 pi_task_codemode；要查/停任务用任务面三工具。派不派自己判断——路由表第一行写了代价。"
-};
-function renderRouteIndex(surface, detailBase, nudge = true) {
-	const lines = ROUTES.map((route) => `- ${route.name} — ${route.when}。这面怎么走：${route.how[surface]}。细节：${detailBase ? route.detail.split("/").pop() : route.detail}`);
-	let index = [
-		`<ptc>`,
-		...nudge ? [ROUTE_INDEX_LEAD[surface]] : [],
-		...detailBase ? [`详情目录：${detailBase}`] : [],
-		"路由表（一条一行，详情按需 read）：",
-		...lines,
-		`</ptc>`
-	].join("\n");
-	const tokens = estimateTokens(index);
-	if (tokens > 560) index += `\n> WARNING: index over token budget (${tokens} > 560); move detail into docs/routes/*.md`;
-	return index;
-}
 // ../ptc/src/task-binding.ts
 const TASK_BINDING_NAME = "pi_task_ptc";
 const TASK_DOOR_PARAMETERS = _Object_({
@@ -4504,6 +4694,7 @@ function createTaskBinding(door) {
 		}
 	};
 }
+const TASK_RECORDS_BINDING_NAME = "task_records";
 // ../ptc/src/limits.ts
 const DEFAULT_LIMITS = {
 	timeoutMs: 12e4,
@@ -5106,22 +5297,6 @@ function validateWorkflowArgs(args) {
 		throw new Error(`workflow args 必须是 JSON 值：${error instanceof Error ? error.message : String(error)}`);
 	}
 }
-// ../task/src/list-tasks.ts
-function selectVisibleTasks(records, recentCompletedLimit = 10) {
-	const inFlight = records.filter((record) => !isTerminal(record.status));
-	const recentCompleted = records.filter((record) => isTerminal(record.status)).sort((a, b) => (b.finishedAt ?? 0) - (a.finishedAt ?? 0)).slice(0, recentCompletedLimit);
-	return [...inFlight, ...recentCompleted];
-}
-function taskFaceVisible(records) {
-	return records.length > 0;
-}
-// ../task/src/lifecycle.ts
-function listTasks(registry, recentCompletedLimit) {
-	return selectVisibleTasks(registry.list(), recentCompletedLimit);
-}
-function faceVisible(registry) {
-	return taskFaceVisible(registry.list());
-}
 // src/session.ts
 function assemblePtcSession(options = {}) {
 	const registry = new TaskRegistry(options.onTransition);
@@ -5139,14 +5314,46 @@ function assemblePtcSession(options = {}) {
 			...opts,
 			task
 		}),
-		listTasks: (recentCompletedLimit) => listTasks(registry, recentCompletedLimit),
+		taskListSnapshot: (query) => taskListSnapshot(registry, query),
 		stopTask: (taskId, reason) => engine.stop(taskId, reason),
 		faceVisible: () => faceVisible(registry),
 		shutdown: () => engine.shutdown(),
 		readOutput: (taskId) => engine.readOutput(taskId),
 		outputSize: (taskId) => engine.outputSize(taskId),
 		readOutputTail: (taskId, maxBytes) => engine.readOutputTail(taskId, maxBytes),
-		readArchivedRecord: (taskId) => engine.readArchivedRecord(taskId)
+		readArchivedRecord: (taskId) => engine.readArchivedRecord(taskId),
+		readArchivedRecords: () => engine.readArchivedRecords(),
+		get sessionId() {
+			return options.context?.sessionId;
+		}
+	};
+}
+/**
+* 引擎运行时上下文：孩子的模型默认继承父会话的当前模型。
+* 优先级（旧 ADR-0044）：调用参数 → agent 定义 → 会话模型（缺省继承）。
+* sessionModel 是活 getter——派发那一刻才读，用户中途换模型也跟着换；
+* floor 0.86 也有 ctx.model（实测 0.86.0 的 ExtensionContext.model 同为活 getter，provider/id 同形）→ 无版本门；
+* 会话没有模型 → undefined → 不发 --model；扩展被卸载后 ctx 的 getter 会抛（pi 的 assertActive）→ 吞掉退回旧行为。
+*/
+function buildEngineContext(ctx, piVersion) {
+	return {
+		depth: 0,
+		piVersion,
+		get sessionModel() {
+			try {
+				const model = ctx.model;
+				return model ? `${model.provider}/${model.id}` : void 0;
+			} catch {
+				return;
+			}
+		},
+		get sessionId() {
+			try {
+				return ctx.sessionManager.getSessionId();
+			} catch {
+				return;
+			}
+		}
 	};
 }
 // src/index.ts
@@ -5250,10 +5457,7 @@ function piPtcEntry(pi) {
 		session = assemblePtcSession({
 			onTransition: () => applyTaskFaceVisibility(),
 			whyEnabled: () => whyEnabledOverride ?? whyEnabledPersisted,
-			context: {
-				depth: 0,
-				piVersion
-			},
+			context: buildEngineContext(ctx, piVersion),
 			engine: {
 				notifications,
 				resolveAgent: (name, scope) => findAgent(name, agentDirs, scope),
@@ -5329,6 +5533,24 @@ function piPtcEntry(pi) {
 		};
 		registerTaskFace(registerTracked, session, surface);
 		applyTaskFaceVisibility();
+		let compactReminderPending = false;
+		pi.on("session_compact", () => {
+			compactReminderPending = true;
+		});
+		pi.on("context", (event) => {
+			if (!compactReminderPending) return void 0;
+			compactReminderPending = false;
+			const reminder = compactedTaskReminder(session.registry);
+			if (!reminder) return void 0;
+			return { messages: [...event.messages, {
+				role: "user",
+				content: [{
+					type: "text",
+					text: reminder
+				}],
+				timestamp: Date.now()
+			}] };
+		});
 		let toolContext;
 		const getBindings = () => createBindingTable(pi, session, () => toolContext);
 		registerPtcTools(registerTracked, {
@@ -5482,6 +5704,11 @@ function createBindingTable(pi, session, getToolContext) {
 	}]));
 	const taskBinding = createTaskBinding(session);
 	table[TASK_BINDING_NAME] = async (args) => withDeliveryNote(await taskBinding.execute(args));
+	table[TASK_RECORDS_BINDING_NAME] = async (args) => {
+		const records = session.registry.list();
+		if (args?.scope !== "all") return records;
+		return [...records, ...await session.readArchivedRecords()];
+	};
 	return table;
 }
 function registerPtcTools(registerTool, options, surface) {
@@ -5494,9 +5721,23 @@ function registerTaskFace(registerTool, session, surface) {
 		name: "ptc_task_list",
 		label: "任务列表",
 		description: TOOLS.ptc_task_list.description(surface),
-		parameters: _Object_({}),
+		parameters: _Object_({
+			scope: Optional(Union([Literal("recent"), Literal("all")], { description: "recent = 只热存（默认）；all = 含压缩归档（更全但更慢）" })),
+			limit: Optional(Number$1({ description: "取多少条（默认 50，上限 200）" })),
+			status: Optional(Union(TASK_STATUSES.map((s) => Literal(s)), { description: "只看某个状态" })),
+			session: Optional(String$1({ description: "按会话筛：current = 本会话，或给一个会话 id" }))
+		}),
 		defaultActive: false,
-		execute: async () => textResult(session.listTasks())
+		execute: async (_id, args) => {
+			const query = {
+				scope: args.scope,
+				limit: args.limit,
+				status: args.status,
+				session: args.session === "current" ? session.sessionId : args.session
+			};
+			const archived = query.scope === "all" ? await session.readArchivedRecords() : [];
+			return textResult(taskListSnapshot(session.registry, query, archived));
+		}
 	});
 	registerTool({
 		name: "ptc_task_output",
@@ -5507,24 +5748,9 @@ function registerTaskFace(registerTool, session, surface) {
 		execute: async (_id, args) => {
 			const record = session.registry.get(args.task_id) ?? await session.readArchivedRecord(args.task_id);
 			if (!record) return textResult({ error: `unknown task id ${args.task_id}` });
-			const outputBytes = await session.outputSize(args.task_id);
-			if (outputBytes === void 0) return textResult(withDeliveryNote(record));
-			if (outputBytes > 51200) {
-				const { text } = applyAdr0015Truncation$1(await session.readOutputTail(args.task_id, 51200) ?? "");
-				return textResult(withDeliveryNote({
-					...record,
-					output: text,
-					guidance: renderLongOutputGuidance({
-						bytes: outputBytes,
-						report: record.report,
-						reportChannel: record.reportChannel ?? "none"
-					})
-				}));
-			}
-			const { text } = applyAdr0015Truncation$1(await session.readOutputTail(args.task_id, 51200) ?? "");
 			return textResult(withDeliveryNote({
 				...record,
-				output: text
+				...await readTaskOutput(session, record)
 			}));
 		}
 	});
@@ -5569,4 +5795,4 @@ function registerTaskDoor(registerTool, session, surface) {
 		}
 	});
 }
-export { assemblePtcSession, piPtcEntry as default, withDeliveryNote };
+export { assemblePtcSession, buildEngineContext, piPtcEntry as default, withDeliveryNote };

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.3.0",
   "description": "Programmable tool calling (PTC) and subagent fan-out for pi",
   "keywords": [
     "pi",