on_tool_finish: acquire progress_accounting_lock persist uncached-input + output and wall-clock delta if checkpoint crosses budget: status = BudgetLimited inject one wrap-up steering if the turn is still active
当前实现把 Goal 放在 SQLite home 下的独立文件 goals_1.sqlite。启动时，state runtime 会为它单独打开连接池，再构造 GoalStore。当前迁移中的核心表可以简化为：
1 2 3 4 5 6 7 8 9 10 11
CREATE TABLE thread_goals ( thread_id TEXT PRIMARY KEYNOT NULL, goal_id TEXT NOT NULL, objective TEXT NOT NULL, status TEXT NOT NULL, token_budget INTEGER, tokens_used INTEGERNOT NULLDEFAULT0, time_used_seconds INTEGERNOT NULLDEFAULT0, created_at_ms INTEGERNOT NULL, updated_at_ms INTEGERNOT NULL );
User prompt -> model reasoning -> tool call <-> environment -> final assistant message -> turn ends, wait for user
Goal 模式
User objective -> normal agent turn -> thread becomes idle -> Goal Runtime checks durable state and scheduling conditions -> start another turn when continuation is allowed -> repeat until the lifecycle changes
按键、过滤模式、以及它和 /fork、/clone 的分工，属于使用手册的范畴，sessions.md[2] 里写得很全。这里只留一条和存储机制直接相关的：切走一条分支时 pi 会问你要不要给放弃的那条做个摘要——选了就写一条 branchSummary entry 挂在新位置上（就是下面那张类型表里的一行）。这样你换到分支 B 之后模型仍知道”A 试过什么”，而不必把 A 的全部消息重放一遍。
The messages above are a conversation to summarize. Create a structuredcontext checkpoint summary that another LLM will use to continue the work.Use this EXACT format:## Goal[What is the user trying to accomplish? Can be multiple items if thesession covers different tasks.]## Constraints & Preferences- [Any constraints, preferences, or requirements mentioned by user]- [Or "(none)" if none were mentioned]## Progress### Done- [x] [Completed tasks/changes]### In Progress- [ ] [Current work]### Blocked- [Issues preventing progress, if any]## Key Decisions- **[Decision]**: [Brief rationale]## Next Steps1. [Ordered list of what should happen next]## Critical Context- [Any data, examples, or references needed to continue]- [Or "(none)" if not applicable]Keep each section concise. Preserve exact file paths, function names,and error messages.
- [Or "(none)" if none were mentioned] ——明确要求”没有就写 none”。留空会让下一个模型分不清”没约束”和”忘了写”。
最后一句是全篇最要紧的：Preserve exact file paths, function names, and error messages. 摘要的天性是抽象，而抽象恰恰会毁掉 agent 最需要的东西——src/config.ts 被概括成”配置文件”，模型就得重新去找一遍。这一句把”精确的字符串”从压缩里豁免出去。
配套的 system prompt（SUMMARIZATION_SYSTEM_PROMPT）只有三句，专治一个具体的失败模式：
1
You are a context summarization assistant. Your task is to read aconversation between a user and an AI assistant, then produce astructured summary following the exact format specified.Do NOT continue the conversation. Do NOT respond to any questions inthe conversation. ONLY output the structured summary.
后面那两个 Do NOT 是有来由的：你把一段对话原样塞给模型，它的本能是接着往下聊——尤其当历史最后一条是个问句时。为了同一个目的，pi 还在代码层面加了一道保险：serializeConversation() 把消息数组拍平成纯文本（[User]: ... / [Assistant]: ... 这种前缀行），再用 <conversation> 标签包起来当一条 user 消息发出去。模型收到的不是”一段待续的对话”，而是”一份要处理的资料”。
最终拼出来的 prompt 结构是：
1
<conversation>[User]: 帮我看看这个项目[Assistant]: read(path="package.json")...</conversation>[如果是第二次压缩，这里还有 <previous-summary>...</previous-summary>]The messages above are a conversation to summarize. ...（上面那段）
下面两段代码是我为了讲解写的示例，不是 pi 自带的功能——.pi/extensions/ 目录默认是空的，你不放文件进去，pi 什么额外的事都不做。想让它们生效，得自己把文件创建在 ~/.pi/agent/extensions/（全局，所有项目生效）或项目根的 .pi/extensions/（只对这个项目生效）；项目级的那份还要等项目被 trust 之后才加载。放好后 /reload 热加载，或者临时试一下用 pi -e ./inject-git-status.ts。
pi 自带的例子在装好的包里：examples/extensions/ 下有四十来个可直接跑的文件，claude-rules.ts 就是一个正经的 before_agent_start 实现（扫 .claude/rules/ 把规则清单拼进 system prompt）。下面第二段代码就是照它的写法改的。
“It is strongly recommended to use an allow-list approach whenever possible because such an approach is more robust and simple. A deny-list will have to be updated whenever a potentially dangerous system call is added.”
Pi 的 sandbox extension 走的是不同的路：它通过 sandbox-runtime 的代理来过滤域名（前面讲过），所以 Pi 的策略里网络不是全放行的——白名单外的域名会被代理拒绝。这个白名单就是 前面看过的那个 allowedDomains 字段，配置在 ~/.pi/agent/extensions/sandbox.json（全局）或 .pi/sandbox.json（项目级）里。
为什么网络域名过滤这么难？
agent-safehouse[4] 项目的文档说得很直白：”blocking exfiltration/C2 is explicitly NOT a goal for this sandbox.” 因为要在内核层做域名过滤，你需要一个额外的 DNS 代理——在沙箱外面跑一个只解析白名单域名的 DNS 服务器，然后强制沙箱内的程序通过它解析。这不是一个 SBPL 策略能搞定的事。
]]>对比白名单与黑名单策略，分析 macOS Seatbelt、Linux bubblewrap 以及 pi 沙箱的策略设计。Pi Extension 的第一枪：Sandbox Extension（1）https://www.wyf219.top/posts/pi-sandbox-extension-part-1/2026-08-11T22:00:00.000Z2026-08-11T22:00:00.000Z从操作系统隔离机制出发，拆解 pi Sandbox Extension 的命令包装、平台检测与安全边界。
临江仙 · 沙箱
自律从来难自缚， 纸条贴遍门窗。 手机在兜誓不刷， 三更破了戒， 还怨意志伤。
须知锁匙交他手， 内核铁壁高墙。 任凭代码百般狂， 柜员摇头处， 一句不商量。
Pi 的沙箱：一个不存在的内置功能
上一篇我们聊了 Pi 的扩展系统：什么都不内置怎么长出一切——Pi 自己不干活，全靠扩展干。那你可能想问：Pi 有沙箱吗？它怎么保护你的系统不被 AI 搞崩？
答案是：没有。Pi 没有内置沙箱。
我知道你可能觉得被骗了——一个能跑任意 shell 命令的 AI 工具，居然不带安全围栏？但 Pi 的文档说得很直白：
Pi does not include a built-in sandbox… A partial in-process sandbox would be easy to misunderstand as a security boundary while still depending on the host shell, filesystem, package managers, credentials, and extension code.
翻译过来：半吊子的沙箱比没有沙箱更危险，因为它给你一种虚假的安全感。
不过——这才是有意思的地方——Pi 的扩展机制可以接入真正的 OS 级沙箱。Pi 自带了一个 sandbox extension 示例[1]，用 macOS 的 sandbox-exec 和 Linux 的 bubblewrap 给 bash 命令套上内核级别的限制。
import osALLOWED_WRITE_DIR = "/tmp/safe/"def safe_write(path, content): real = os.path.realpath(path) if not real.startswith(ALLOWED_WRITE_DIR): raise PermissionError(f"拦截: {path} 不在 {ALLOWED_WRITE_DIR} 里") with open(path, "w") as f: f.write(content)
跑一下：
1
python3 -c 'import osALLOWED_WRITE_DIR = "/tmp/safe/"def safe_write(path, content): real = os.path.realpath(path) if not real.startswith(ALLOWED_WRITE_DIR): raise PermissionError(f"拦截: {path} 不在 {ALLOWED_WRITE_DIR} 里") with open(path, "w") as f: f.write(content)os.makedirs("/tmp/safe", exist_ok=True)safe_write("/tmp/safe/hello.txt", "允许的\n")print("写入 /tmp/safe/hello.txt 成功")try: safe_write("/tmp/evil.txt", "不应该出现\n")except PermissionError as e: print(f"被拦截: {e}")'
承认现实 — 一个需要跑 npm install、pip install、git commit、启动 language server 的工具，不可能在进程内做出有意义的限制。能做的是：把需要权限的操作委托给一个被内核管着的子进程。这正是 sandbox extension 做的事。
Pi sandbox extension 架构
]]>从操作系统隔离机制出发，拆解 pi Sandbox Extension 的命令包装、平台检测与安全边界。Pi 的扩展系统：什么都不内置，怎么长出一切https://www.wyf219.top/posts/pi-extension-system/2026-08-09T11:47:00.000Z2026-08-09T11:47:00.000Z解析 pi 的扩展系统，理解工具、命令、快捷键与事件钩子如何让核心保持精简并持续扩展。
pi 的作者 Mario Zechner（libGDX 的作者）在 2025 年做 pi 时做了一个少见的选择：README 的 Design Principles 里列了一长串”不做”——没有 plan 模式，没有 TODO 管理，没有内置 MCP，没有子 agent，没有记忆系统。同期 Claude Code 和 Cursor 每个版本都在加功能，pi 的发版记录里加的是钩子和事件——给别人用的接口，不是自己的功能。
本篇讲的 steering/followUp 队列是普通数组，循环主动去查。下一篇讲的 EventStream 是异步队列——消费者不用主动查，有事件时自动被唤醒。它用区区几十行代码实现了”不烧 CPU 的等待”，是 pi 里打字机效果、实时工具执行进度的底层基础。
敬请期待。
]]>解析 pi 的 steering 与 follow-up 队列，理解用户插话、任务追加和 agent 循环之外的调度机制。读懂 Pi，你就是 AI 应用之王https://www.wyf219.top/posts/pi-agent-loop-production/2026-08-01T07:00:00.000Z2026-08-01T07:00:00.000Z逐段解析 pi 的 agent-loop.ts，理解双层循环、工具调用、流式响应和事件广播等生产级机制。
之前我们亲手写了 100 行的 mini-pi，理解了 agent 循环的骨架。这一部分我们不再写新代码——直接打开 pi 的 agent-loop.ts[1]，逐段读它的生产级实现。
你会发现你在 Part 1 写的每一行都有对应物，但 pi 在每个关键位置都多了一层保护。这些”多出来的”不是过度设计——它们是被真实用户的真实 bug 逼出来的。
async function runLoop(..., signal?: AbortSignal)async function streamAssistantResponse(..., signal?: AbortSignal)async function prepareToolCall(..., signal?: AbortSignal)async function executePreparedToolCall(prepared, signal?: AbortSignal, ...)async function finalizeExecutedToolCall(..., signal?: AbortSignal)
这个判断有据可查：Anthropic 在《Building effective agents》里的原话是，agent “通常只是 LLM 在一个循环里、根据环境反馈来使用工具”（”typically just LLMs using tools based on environmental feedback in a loop”）。模型公司自己都这么说——那层神秘感是营销给的，不是代码给的。
所以这个教程的玩法是：我们不从理论开始，而是亲手写一个一百行上下的微型 agent，给它起名 mini-pi。它有两个工具，能查看真实的项目目录、读真实的文件、回答你关于这个项目的问题。写完之后，我们翻开 pi 真正的源码对照——你会发现你写的东西和一个 61.9k star 的生产级项目，骨架完全一致。
privatevoiddfs(TreeNode root, long s, int targetSum, Map<Long, Integer> cnt){ if(root==null){ return; } s += root.val; ans += cnt.getOrDefault(s-targetSum, 0);
intpre=0; intans=0; for(int x : nums){ pre += x; if(map.containsKey(pre-k)){ ans += map.get(pre-k); } map.put(pre, map.getOrDefault(pre, 0)+1); } return ans; } }
分析：
两个节点j, i, p r e i pre_i prei用于记录含当前节点i之前的所有元素和， p r e j pre_j prej用于记录含当前节点j之前的所有元素和
若[j, ..., i]这一段的和为k，则满足 p r e i − p r e j − 1 = = k pre_i - pre_{j-1} == k prei−prej−1==k，即 p r e i − k = = p r e j − 1 pre_i - k== pre_{j-1} prei−k==prej−1
比较隐藏的一个点：因为数组中存在负数，这个 p r e j − 1 pre_{j-1} prej−1可能出现多次，也就是在不同的j处， p r e j − 1 pre_{j-1} prej−1这个数可能是相同的，表示从不同的起始点j到当前点的子数组和为k的不同情况
分析： 题目给的nums数组是无序的，可以先快排，再双指针找，快排的时间复杂度为 O ( n log n ) \quad O(n \log n) O(nlogn)，双指针前后向中间靠近的复杂度为 O ( n ) \quad O(n) O(n),所以时间复杂度为复杂度为 O ( n log n ) \quad O(n \log n) O(nlogn) 代码3： 哈希表：
int ans = 0; int count = 0; for(int i=1; i<nums.size(); i++){ if(nums[i] == nums[i-1]+1) count++; elseif(nums[i] == nums[i-1]) continue; else{ ans = max(count, ans); count = 0; } } return max(++count, ++ans); } };
分析：
按照常人思考的逻辑从小到大一个个往后找，找的过程中满足+1和去重的条件，时间复杂度为：排序+找 = O ( n log n ) + O ( n ) = O ( n log n ) \quad O(n \log n)+\quad O(n) =\quad O(n \log n) O(nlogn)+O(n)=O(nlogn)
unordered_set 基于哈希表实现，插入操作的平均时间复杂度为 O ( 1 ) O(1) O(1)。遍历长度为 n n n 的数组，每个元素插入一次，总时间复杂度为 O ( n ) O(n) O(n)；当所有元素哈希冲突严重时（例如哈希函数极不均匀），每次插入需要遍历链表，单次插入退化为 O ( n ) O(n) O(n)，总时间复杂度为 O ( n 2 ) O(n²) O(n2)，所以复杂度取决于nums数组，
水量 = min ( h e i g h t [ l ] , h e i g h t [ r ] ) ∗ ( r − l ) \text{min}(height[l], height[r])*(r-l) min(height[l],height[r])∗(r−l)
下一次是左边向右移动还是右边向左移动？
假设 h e i g h t [ l ] < h e i g h t [ r ] height[l]<height[r] height[l]<height[r],此时之间的距离为 ( r − l ) (r-l) (r−l)，此时的容量为 h e i g h t [ l ] ∗ ( r − l ) height[l]*(r-l) height[l]∗(r−l)
当右指针左移一个（高的一边向内移动），此时距离为 ( r − 1 − l ) (r-1-l) (r−1−l)，当：
h e i g h t [ r − 1 ] > h e i g h t [ r ] height[r-1] > height[r] height[r−1]>height[r]时， 高度= m i n ( h e i g h t [ l ] , h e i g h t [ r − 1 ] ) = h e i g h t [ l ] = m i n ( h e i g h t [ l ] , h e i g h t [ r ] ) min(height[l], height[r-1]) = height[l] = min(height[l], height[r]) min(height[l],height[r−1])=height[l]=min(height[l],height[r])
h e i g h t [ r − 1 ] < h e i g h t [ r ] height[r-1] < height[r] height[r−1]<height[r]时，高度 = m i n ( h e i g h t [ l ] , h e i g h t [ r − 1 ] ) < = m i n ( h e i g h t [ l ] , h e i g h t [ r ] ) min(height[l], height[r-1]) <= min(height[l], height[r]) min(height[l],height[r−1])<=min(height[l],height[r])
综上， m i n ( h e i g h t [ l ] , h e i g h t [ r − 1 ] ) < = m i n ( h e i g h t [ l ] , h e i g h t [ r ] ) min(height[l], height[r-1]) <= min(height[l], height[r]) min(height[l],height[r−1])<=min(height[l],height[r])
所以有： m i n ( h e i g h t [ l ] , h e i g h t [ r − 1 ] ) ∗ ( r − 1 − l ) < m i n ( h e i g h t [ l ] , h e i g h t [ r ] ) ∗ ( r − l ) min(height[l], height[r-1])*(r-1-l) < min(height[l], height[r]) * (r-l) min(height[l],height[r−1])∗(r−1−l)<min(height[l],height[r])∗(r−l)
所以，每次都选择高度小的一边向内侧移动
总结
看题解不难但是自己证明出来却需要很大的难度，膜而拜之~ orz~
6. 三数之和
20min 题目： 给你一个整数数组nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。
