tako 文档 GitHub

19v6-04 · 验收(curl 手打)

本篇是 doc/19-v6 文档集的验收篇:用例 → curl 命令 → 期望字节。改契约字节必须同步改本篇期望并重跑。 端点契约真源在 19v6-01;游标语义在 19v6-02;响应信封与业务码表在 doc/40。

2026-10-22:验收有了机器可重跑的那一份(scripts/acceptance/)。 本篇是人读版(散文),机器真源是 scripts/acceptance/expected.json;两份同批改, scripts/acceptance/check-expected.sh 守两边的用例号集合一致。

「重跑」从现在开始是一句命令,不是「照着散文手打三十条 curl 再肉眼比一次」:

# 起一个隔离引擎(起法见 scripts/acceptance/README.md),然后:
TAKO_BASE=http://127.0.0.1:8943 TAKO_ENV=yk-tako-eino/.env \
  python3 scripts/acceptance/assert_contract.py     # 红打 ❌、退出码非零

散文期望跑歪了不会红,红的是机器真源。本篇的作用从「唯一的期望来源」降级为 「同一份内容的人读版」——要改期望字节,两边都改。

用例号 ↔︎ 机器清单的对应:expected.json 的 cases[].case 就是本篇的「用例 N」, 一一对上(当前已断言:0/1/2/3/4/10/12/13/14/15/16/17/18/25/26/28/29/30/31/32/33/35/36/37/38/44/45/46/47/48/49/50/51/52/53/54; 5/6/7/8/9/11/19/20/21/22/23/24/27/34/39/40/41/42/43 在 declared_not_asserted 里登记了暂不断言的原因, 其中 8 的活体判红在 taskboard_crash.sh、9 的在 events_live.sh、11 的在 question_crash.sh、 39–43 的在 memory_*_live.sh 六件(doc/65 §13.3); 30/31 的个别分支也各有一条登记)。 2026-11-11 新增:51–54 编排计划修订、继续、Task 问题与「需要我处理」聚合(doc/72)。 51/52/53/54 的期望字节全部来自调度关闭的隔离引擎实跑(-task-interval=-1s); 同批把用例 44 的 Task 视图补上 planCheckpoint → createdRevision、用例 48 的组半补上 planRevision → planHold(都插在 doc/72 §4.7 规定的位置,旧字段相对顺序不变)。 2026-11-10 新增:44–50 持久 Task 与编排(doc/70)。这一组的引擎要调度关闭起法 (-task-interval=-1s),状态字节才确定;用例 44 里的 require_status 探针会实测 ready 是否三秒不被领走,调度没关就红在这里。来源会话没有 HTTP 建入口,用 SQL 造 (INSERT … RETURNING id,运行器的 capture_stdout 取 stdout 第一行)。 2026-11-01 新增:32 读分页、33 bash 输出留存(doc/58)——这两条打的是 dev 口 (/api/dev/workspace/read、/api/dev/workspace/bash),因为读工具与 bash 的输出字节是 模型侧字节,四个产品端点打不到它们;33 需要 macOS 的 sandbox-exec,清单里标了 needs=sandbox,那台机器上跳过并说明原因。 另有快闸:yk-tako-eino/internal/runengine/contract_test.go 钉住信封字节序、 session/frames/log 的响应字节、帧 kind 词表与业务码值——不打模型、不用 API Key,每拍收尾随 go test ./internal/runengine 就跑。

2026-10-22 校准:全部业务端点换信封(doc/40 A7-1…A7-6 落地)。 此前本篇的四个业务端点成功体是裸 JSON、失败体是 {"error":"..."};现在成功与失败都回 {code,message,data}——业务体进 data,失败是数字业务码 + 弹窗文案。 data 里的字段名与顺序一个没动(下面各用例里 data 内层就是原来的字节),只是外面多了层壳。 两样不进信封:GET /api/media 的成功体是图片字节;SSE 帧面(doc/31)。 下面各用例的期望字节已按现行代码更新;实跑实录见本篇末尾的「2026-10-22 重放实录」。

2026-10-21 校准:本篇的 session 期望字节此前停在 doc/28 之前(只写 liveRunId + runlogOffset), 而实际响应自 doc/17 §4(lastRunStatus)、doc/30 A1(lastRunId)、doc/35 A4(workspaceId)起 已多三个字段——照旧字节断言会误判。现已按现行代码(server.go 的 sessionResponse)对齐。 同批把 19v6-01 §2 的帧 kind 断言从五种改为七种(补 usage / resume),并同步 index 概念表与 doc/31。

校准的实跑实录(2026-10-21,8901,带登录态)——上面两条 session 期望是打出来的,不是推的:

# 投递(临时账号 + 已配租户模型)
POST /api/runs  {"messageId":"m_v1","text":"只回复 ok"}
→ 202 {"sessionId":"s_01M5F21D10BJCYTAREND75N0B4","runId":"r_01M5F21D106HPH402DGBQETJTF","messageId":"m_v1"}

# 跑中
GET /api/sessions/s_01M5F21D10BJCYTAREND75N0B4
→ 200 {"liveRunId":"r_01M5F21D106HPH402DGBQETJTF","runlogOffset":1,"lastRunStatus":"running","lastRunId":"r_01M5F21D106HPH402DGBQETJTF","workspaceId":null}
   字段序实测 = liveRunId → runlogOffset → lastRunStatus → lastRunId → workspaceId

# 定稿后
GET /api/sessions/s_01M5F21D10BJCYTAREND75N0B4
→ 200 {"liveRunId":"","runlogOffset":2,"lastRunStatus":"complete","lastRunId":"r_01M5F21D106HPH402DGBQETJTF","workspaceId":null}

# frames(含 usage 帧——第 6 种 kind 的实锤)
GET /api/runs/r_01M5F21D106HPH402DGBQETJTF/frames?eventOffset=0
→ 200 {"frames":[
     {"eventOffset":1,"kind":"start","agent":"","model":"","messageId":"m_v1"},
     {"eventOffset":2,"kind":"delta","agent":"","model":"deepseek/deepseek-flash","text":"ok"},
     {"eventOffset":3,"kind":"usage","agent":"","model":"deepseek/deepseek-flash","promptTokens":3932,"completionTokens":2,"totalTokens":3934,"window":256000},
     {"eventOffset":4,"kind":"terminal","agent":"","model":"","status":"complete"}
   ],"nextOffset":4,"status":"done"}

resume 帧没有出现在这次实录里——它只在崩溃后接管那条路径上产生(doc/30 §8.3), 它的字节与验收见 doc/30,不在本篇矩阵内。改动契约字节后必须重跑本篇。

2026-10-21 补:doc/28 之后的认证前置。 自 doc/28 起,本篇的四个业务端点全部挂 RequireAuth—— 下面用例里的 curl 每一条都要带 -H "Authorization: Bearer $TOK",否则一律 401。 补录一段实测(2026-10-21,引擎 8943/8944、隔离库、Redis db 7):

# 无 Authorization:四个端点同形
POST  /api/runs              → 401 {"code":111102,"message":"请先登录","data":null}
GET   /api/sessions/{id}     → 401 {"code":111102,"message":"请先登录","data":null}
GET   /api/runs/{id}/frames  → 401 {"code":111102,"message":"请先登录","data":null}
GET   /api/sessions/{id}/log → 401 {"code":111102,"message":"请先登录","data":null}

# 带登录态:业务端点也是信封(2026-10-22 起,doc/40)
POST /api/runs              → 202 {"code":0,"message":"","data":{"sessionId":"s_01…","runId":"r_01…","messageId":"m_1"}}
GET  /api/sessions/{id}     → 200 {"code":0,"message":"","data":{"liveRunId":"r_01…","runlogOffset":1,"lastRunStatus":"running","lastRunId":"r_01…","workspaceId":null}}
GET  /api/runs/{id}/frames  → 200 {"code":0,"message":"","data":{"frames":[…],"nextOffset":33,"status":"done"}}
GET  /api/sessions/{id}/log → 200 {"code":0,"message":"","data":{"rows":[…],"nextOffset":2}}

# 忙时拒绝(第一场还在跑时)
POST /api/runs {"sessionId":"s_01","messageId":"m_2"} → 409 {"code":112101,"message":"这场会话正在跑,等它跑完再发","data":null},runlog 行数不变

体例统一:所有 JSON 接口一律 {code,message,data}(doc/40);失败码表见 doc/40 §4。 例外只有两样——media 的图片成功体、SSE 帧面。

# ═══ 用例 0:认证与前置(doc/28 起,下面每个用例都依赖它)═══
# 业务四端点自 doc/28 起全部挂 RequireAuth:不带 Authorization 一律 401 信封体。
# 注意体例——**全部 JSON 接口一律 {code,message,data} 信封**(doc/40)。

curl -X POST localhost:8080/api/auth/signup -d '{"email":"you@example.com","password":"changeme123"}'
→ 201 {"code":0,"message":"","data":{"user":{"id":"u_01","email":"you@example.com"},"tenant":{"id":"t_01","kind":"personal","name":"you"},"membership":{"tenantId":"t_01","role":"owner"},"accessToken":"…","tokenType":"Bearer","expiresIn":900,"refreshToken":"…"}}
   把 accessToken 放进 $TOK(下文每个 curl 都带 -H "Authorization: Bearer $TOK")。

# 租户模型:租户没配模型密钥时,POST /api/runs 回 409 {"code":111408,"message":"这个工作区的模型还不可用","data":null},run 根本起不来。
curl -X PUT localhost:8080/api/tenants/$TID/runtime-config -H "Authorization: Bearer $TOK" \
  -d '{"modelRef":"deepseek/deepseek-flash","mcpServers":{},"secrets":{"DEEPSEEK_API_KEY":"sk-…"},"sandbox":{"network":false}}'
→ 200 {"code":0,"message":"","data":{"config":{…,"secrets":{"DEEPSEEK_API_KEY":"••••"}}}}   (密钥回显成掩码)

# ═══ 用例 1:投递 → 轮询看生成 → 定稿看历史 ═══
curl -X POST localhost:8080/api/runs -H "Authorization: Bearer $TOK" -d '{"messageId":"m_1","text":"hi"}'
→ 202 {"code":0,"message":"","data":{"sessionId":"s_01","runId":"r_01","messageId":"m_1"}}

curl localhost:8080/api/sessions/s_01 -H "Authorization: Bearer $TOK"
→ 200 {"code":0,"message":"","data":{"liveRunId":"r_01","runlogOffset":1,"lastRunStatus":"running","lastRunId":"r_01","workspaceId":null}}
                                               (刚开跑,user 已进 runlog)

curl 'localhost:8080/api/runs/r_1/frames?eventOffset=0' -H "Authorization: Bearer $TOK"   (反复轮询,frames 逐次变长)
→ frames: [start] → [start,delta,delta] → […,usage,terminal], status: generating→done

curl localhost:8080/api/sessions/s_01 -H "Authorization: Bearer $TOK"
→ 200 {"code":0,"message":"","data":{"liveRunId":"","runlogOffset":2,"lastRunStatus":"complete","lastRunId":"r_01","workspaceId":null}}
                                               (定稿后)

curl 'localhost:8080/api/sessions/s_01/log?runlogOffset=0' -H "Authorization: Bearer $TOK"
→ rows:[{1,user,"hi"},{2,assistant,"…全文"}], nextOffset:2

curl localhost:8080/api/runs/r_01/skills -H "Authorization: Bearer $TOK"
→ 200 {"code":0,"message":"","data":{"runId":"r_01","loads":[]}}   (doc/52 B1 立端点,B4 填派生;清单末步机器断言这一条)

# ═══ 用例 2:游标增量 & 越界 ═══
curl 'localhost:8080/api/sessions/s_01/log?runlogOffset=1' -H "Authorization: Bearer $TOK"   → 只 offset>1
curl 'localhost:8080/api/runs/r_1/frames?eventOffset=999' -H "Authorization: Bearer $TOK" → {"code":0,"message":"","data":{"frames":[],"nextOffset":999,"status":"generating"}}
curl 'localhost:8080/api/sessions/s_01/log?runlogOffset=999' -H "Authorization: Bearer $TOK" → {"code":0,"message":"","data":{"rows":[],"nextOffset":999}}

# ═══ 用例 3:带未知 sessionId / 未知 run ═══
curl -X POST localhost:8080/api/runs -H "Authorization: Bearer $TOK" -d '{"sessionId":"s_nope","messageId":"m_9","text":"hi"}'
→ 404 {"code":112001,"message":"找不到这场会话","data":null}
curl localhost:8080/api/sessions/s_nope -H "Authorization: Bearer $TOK"
→ 404 {"code":112001,"message":"找不到这场会话","data":null}
curl localhost:8080/api/sessions/s_nope/log -H "Authorization: Bearer $TOK"
→ 404 {"code":112001,"message":"找不到这场会话","data":null}
curl 'localhost:8080/api/runs/r_nope/frames' -H "Authorization: Bearer $TOK"
→ 200 {"code":0,"message":"","data":{"frames":[],"nextOffset":0,"status":"gone"}}   (未知 run 不是 404——19v6-01 §0)

# ═══ 用例 4:忙时诚实拒绝 ═══
(会话有活 run 时)curl -X POST localhost:8080/api/runs -H "Authorization: Bearer $TOK" -d '{"sessionId":"s_01","messageId":"m_2","text":"急"}'
→ 409 {"code":112101,"message":"这场会话正在跑,等它跑完再发","data":null},且 runlog/runlive 里没有 m_2 的任何痕迹(忙拒后 runlog 行数不变)

# ═══ 用例 5:单批上限 W(W=200 时造不出截断,dev 起服务把它调小:-batch-window 3)═══
(runlog 已有 5 条时)
curl 'localhost:8080/api/sessions/s_01/log?runlogOffset=0' -H "Authorization: Bearer $TOK"  → 只返回 offset 1..3,nextOffset:3
curl 'localhost:8080/api/sessions/s_01/log?runlogOffset=3' -H "Authorization: Bearer $TOK"  → 返回 offset 4..5,nextOffset:5
curl 'localhost:8080/api/sessions/s_01/log?runlogOffset=5' -H "Authorization: Bearer $TOK"  → {"code":0,"message":"","data":{"rows":[],"nextOffset":5}}
# 往回拨(翻页游标)同样合法:
curl 'localhost:8080/api/sessions/s_01/log?runlogOffset=1' -H "Authorization: Bearer $TOK"  → 返回 offset 2..4(受 W=3 限),nextOffset:4
# frames 端点同一条规则(2026-10-21 实测,引擎 -batch-window 3):
curl 'localhost:8080/api/runs/r_1/frames?eventOffset=0' -H "Authorization: Bearer $TOK"   → offset 1..3,nextOffset:3
curl 'localhost:8080/api/runs/r_1/frames?eventOffset=3' -H "Authorization: Bearer $TOK"   → offset 4..6,nextOffset:6
curl 'localhost:8080/api/runs/r_1/frames?eventOffset=24' -H "Authorization: Bearer $TOK"  → 末批 offset 25..26(usage,terminal),nextOffset:26
# 客户端必须跟着 nextOffset 走:只拉 eventOffset=0 那一批,永远看不到后面的 terminal。

# ═══ 用例 6:工具循环(get_time)——tool 帧 / runlog 扩展行 / 跨 run 记忆 ═══
curl -X POST localhost:8080/api/runs -H "Authorization: Bearer $TOK" -d '{"messageId":"m_1","text":"现在几点"}'
→ 202 {"code":0,"message":"","data":{"sessionId":"s_01","runId":"r_01","messageId":"m_1"}}      (记下 s_01)

curl 'localhost:8080/api/runs/r_01/frames?eventOffset=0' -H "Authorization: Bearer $TOK"           (反复轮询)
→ frames 序列:start → tool_call → tool_result → delta… → terminal;tool 帧夹在 delta 之间,顺序即事件序:
  {"eventOffset":2,"kind":"tool_call","agent":"","model":"deepseek/deepseek-flash","name":"get_time","args":"{\"timezone\":\"Asia/Shanghai\"}"}
  {"eventOffset":3,"kind":"tool_result","agent":"","model":"deepseek/deepseek-flash","name":"get_time","output":"2026-10-08 15:04:05 +0800 CST"}
  每帧带 agent(空 = root,含 start/terminal)与 model(生效 ref;start/terminal 为空——19v6-01 §2)

curl 'localhost:8080/api/sessions/s_01/log?runlogOffset=0' -H "Authorization: Bearer $TOK"
→ rows:user(model:"") → tool_call(text:"get_time(…)",payload 非空) → tool_result(text:输出原文,payload 非空) → assistant(全 run delta 累计全文)
  每行带 agent 与 model(user 行 model 空、root 行 model = 主 ref);assistant 行仍是收口替换的锚

# 跨 run 记忆(mh 是模型输入的实证):带 sessionId 再投,模型应凭上一轮的 tool 行接上文
curl -X POST localhost:8080/api/runs -H "Authorization: Bearer $TOK" -d '{"sessionId":"s_01","messageId":"m_2","text":"我刚才问的几点"}'
→ 新一轮正常生成:回复应复述刚才的时间(也可能再调一次 get_time 刷新——两种都算过;
  判据是模型没答「我没查过/不知道」——它看得见历史里的 assistant(tool_calls)+tool 两行)

# ═══ 用例 7:委派(sub agent)——子代理帧/行 + 回传裁剪(机制 19v6-05 §4)═══
# 起服务把回传上限调小演示裁剪(默认 51200 B 太大难现裁;同用例 5 的 W 先例):
#   go run ./cmd/yktako -engine 127.0.0.1:<port> -subagent-return-cap 2000
#   启动日志:subagents: concurrency N, return cap 2000 B;每次 run 起手:agents: <N> spec(s): researcher

curl -X POST localhost:<port>/api/runs -H "Authorization: Bearer $TOK" -d '{"messageId":"m_7","text":"请委派 researcher 写一份分析报告:<具体题材>;一次性直接输出完整全文,不要分多轮——只为逼出超上限回传"}'
→ 202 {"code":0,"message":"","data":{"sessionId":"s_01","runId":"r_01","messageId":"m_7"}}

curl 'localhost:<port>/api/runs/r_01/frames?eventOffset=0' -H "Authorization: Bearer $TOK"          (反复轮询)
→ 帧序(顺序即事件序):
  start → root delta… → {"kind":"tool_call","agent":"","model":"<主 ref>","name":"researcher","args":"<委派任务原文>"}
  → 子代理帧流:{"kind":"delta","agent":"researcher","model":"<该规格生效 ref>","text":"…"}
    (子代理自调工具时,其 tool_call/tool_result 帧同带 agent:"researcher" 与生效 ref)
  → {"kind":"tool_result","agent":"","model":"<主 ref>","name":"researcher","output":"<回传文本>"} → root delta… → terminal{complete}
  回传超上限时 output 尾部带尾缀(原文):[Output truncated: N bytes omitted. Full output preserved in subagent runlog.]

curl 'localhost:<port>/api/sessions/s_01/log?runlogOffset=0' -H "Authorization: Bearer $TOK"
→ 行序(消息粒度;每行 agent/model 恒在):
  user → tool_call(agent:"",text:"researcher({…})") → [agent:"researcher" 的行:其工具活动扩展行 + 终稿 assistant 行(全量)]
  → tool_result(agent:"",text:已裁剪回传) → assistant(agent:"",text:主线程终稿)
  裁剪断言(先裁后落,19v6-05 §4):回传文本 = 子代理终稿行的字节前缀(≤ cap 字节、截点回退到 UTF-8 rune 边界)
  + 尾缀,N = 终稿总字节 − 保留字节(对得上)——模型侧有界(回传/mh 已裁)、审计侧无损(子代理终稿行全文)
  尾缀里的「subagent runlog」= 本端点里 agent:"researcher" 的行(无新端点;客户端按行内 agent 字段跳转)
  多调用并存(同轮委派 + 其他工具)时行序 = 事件到达序:委派块与其他调用块可能交错,
  客户端逐行看 agent/model 即可归属(不做树形重排)

# ═══ 用例 8:任务看板(doc/41)——task 帧 + 看板视图 + 活得过崩溃 ═══
# 帧 kind 词表 8 种:start/delta/tool_call/tool_result/task/usage/terminal(+ 收口用的其它)。
# 新增的 task 帧由看板**写操作**触发(TaskCreate/TaskUpdate),text = 看板紧凑视图
# (每行「#序号 [状态] 主题」+ 一句催更块)——前端不解析自然语言就能画看板。
# 2026-10-22 起**声明但暂不断言**:这条帧要模型真的去调 TaskCreate/TaskUpdate 才造得出,
# 模型行为不稳(换个模型就飘)——同用例 6/7 的处置。帧 kind 词表由 go test 的契约测试钉住,
# 看板的持久化由 TestTaskBoardSurvivesProcessRestart 钉住(另一个 Store 实例读回同一批行)。
# 下面的字节是 2026-10-22 实跑抄下来的真身(deepseek-flash,租户 8901/8943 两处一致)。

curl -X POST localhost:8080/api/runs -H "Authorization: Bearer $TOK" \
  -d '{"messageId":"m_8","text":"我要做三件事:第一列出工作区文件,第二创建 hello.txt,第三读出来。请建任务看板跟踪,每完成一步更新状态。"}'
→ 202 {"code":0,"message":"","data":{"sessionId":"s_01","runId":"r_01","messageId":"m_8"}}

curl 'localhost:8080/api/runs/r_01/frames?eventOffset=0' -H "Authorization: Bearer $TOK"          (反复轮询)
→ 帧序里出现(name = 触发它的工具名;text = 看板紧凑视图;实跑抄下来的真身):
  {"eventOffset":14,"kind":"task","agent":"","model":"deepseek/deepseek-flash","name":"TaskCreate",
   "text":"看板:\n#1 [pending] 列出工作区文件\n(还有 1 项没完成:动手前把它标 in_progress,做完立刻标 completed;卡住就建一条 blocker 记录)"}
  状态翻转后再发一张(name:"TaskUpdate",text 里那一行变 [completed])
  帧的字段集与其它帧同形(eventOffset/kind/agent/model/name/text)——客户端按 kind 分派即可

# 看板活得过崩溃(doc/41 §5.1):正本在 PG 表 run_tasks,不在进程内存(旧线的死因)
psql -d tako -tAc "SELECT count(*) FROM run_tasks WHERE run_id='r_01'"
→ 崩前 N 行;kill -9 引擎 → 重启(同 PG/Redis)→ POST /api/runs/r_01/resume → 202 → 续跑到 terminal
→ 崩后仍 N 行(同一批行,没丢也没重;resume 续的是同一个 run_id)

═══ 用例 9:变更事件流(doc/46)——SSE 挂读 + Last-Event-ID 续传 ═══

端点 GET /api/events(SSE,帧面不进信封——doc/40 §6 的同款裁决)。帧两条行:

id: ← stream entry id,续传游标

data: {"seq":"","type":"","id":"<sid|wid>","at":""}

type 词表:session_deleted / workspace_deleted / workspace_renamed(只通知、不带状态,

客户端收到后失效本地并永远跟一次重拉——doc/46 §3.1)。

游标语义:不带 Last-Event-ID = 从 $ 挂起只推新事件(不回放历史);带了 = 从它之后续读。

鉴权:浏览器 EventSource 带不了 Authorization 头,走 ?access_token=(doc/46 §7 第 5 条);

gin 默认日志只记 URL.Path 不带 query。

2026-10-23 起声明但暂不断言(进 declared_not_asserted):SSE 是长连接读取,进不了短连接

断言器——活体判红由 scripts/acceptance/events_live.sh 负责(挂读/静默/续传/query token 五条),

帧 data 字节由 go test 的 TestContractStreamEventBytes 钉住。下面的字节是 2026-10-23 实跑抄的:

curl -N localhost:8080/api/events -H "Authorization: Bearer $TOK" (挂住) 另一个终端:curl -X DELETE localhost:8080/api/sessions/{sid} -H "Authorization: Bearer $TOK" → 挂住的连接立刻收到(实跑真身): id: 1792737898948-0 data: {"seq":"1792737898948-0","type":"session_deleted","id":"s_01M5J5VGJ6VWG1DBCW0R8WA4JG","at":"2026-10-23T06:44:58Z"}

断开后带着游标重连(-H "Last-Event-ID: 1792737898948-0")→ 只收到它之后的新事件,不回放旧的 浏览器姿势:curl -N "localhost:8080/api/events?access_token=$TOK"(同一语义)

═══ 用例 10:人审与问答的码段(doc/47)—— 机器判红:expected.json 10-question-codes ═══

tier=core,不需要模型。下面是 2026-10-23 隔离引擎 8957 的实跑字节:

GET /api/runs/r_nope/questions?status=pending → 404 {"code":112002,"message":"找不到这次运行","data":null}

POST /api/questions/qs_nope/answer {"answer":"x"} → 404 {"code":115002,"message":"找不到这个提问","data":null}

POST /api/questions/qs_nope/answer(不带 Authorization) → 401 {"code":111102,"message":"请先登录","data":null}

补充(要一条可见的 run 才走得到):status 非法值 → 400

{"code":111002,"message":"status 只能是 pending / answered / stale","data":null}

═══ 用例 13:项目列表的 isDefault(doc/48 C1)—— 机器判红:expected.json 13-workspace-isdefault ═══

tier=core,不需要模型。默认项目不可删(服务端 409 114005),页面据此把删除按钮藏起来——

所以服务端必须告诉前端「哪个是默认项目」,这就是 isDefault 这个字段的来由。

下面是 2026-10-23 隔离引擎 8943 的实跑字节:

POST /api/workspaces {"name":"acc-isdefault"} → 201 {"code":0,"message":"","data":{"workspace":{"id":"ws_…","name":"acc-isdefault","createdAt":"…","visibility":"private","owner":true,"isDefault":false}}}

GET /api/workspaces → 200 {"code":0,"message":"","data":{"workspaces":[{"id":"ws_…","name":"…","createdAt":"…","visibility":"private","owner":true,"isDefault":false}]}}

字段序:id → name → createdAt → visibility → owner → isDefault(加在最后,不动既有字段序)。

═══ 用例 14:技能列表(doc/52 A1)—— 机器判红:expected.json 14-skills-empty ═══

tier=core,不需要模型。技能目录是派生视图(doc/52 §4.7):正文在卷上的文件里,

表 skill_rows 只记「叫什么、描述是什么、装在哪」。这一拍是建表与列表端点。

下面是 2026-10-28 隔离引擎 8943 的实跑字节(干净实例):

GET /api/skills → 200 {"code":0,"message":"","data":{"skills":[],"invalid":[]}}

GET /api/skills(不带 Authorization) → 401 {"code":111102,"message":"请先登录","data":null}

data 键序:skills → invalid。skills[] 是生效行,invalid[] 是「盘上有东西但没通过校验」的

行(只放本租户桶的)。空数组不是「没接上」,是「表里确实没有行」。

租户从 token 取(端点没有 :tenantId 路径参数):另一个租户的账号打同一个端点,

看到的也是空数组,看不见别人的行。

空数组这条口径由 go test 钉住(TestSkillsResponseEmptyAndFieldOrder),

活体断言只断「data 有 skills[] 与 invalid[] 两个键」——

活体跑在共享隔离库上,表里可能有别的租户留下的行,断「数组为空」就变成断数据库状态。

元素字段序(name→description→source→path→enabled→bytes→requires→missing→updatedAt→valid)

同样由那条单测逐字钉住。

═══ 用例 15:技能重扫(doc/52 A2)—— 机器判红:expected.json 15-skills-rescan ═══

tier=core,不需要模型。rescan 是「以盘为准」的唯一入口(doc/52 §4.7):

装/删/改一次要动两个系统——盘上的文件、PG 里的行,普通事务兜不住两边一起提交,

rescan 把表重新对齐到盘。

下面是 2026-10-28 隔离引擎 8943 的实跑字节(盘上已放 /skills/demo/SKILL.md):

POST /api/skills/rescan → 200 {"code":0,"message":"","data":{"added":["demo"],"updated":[],"removed":[],"invalid":[],"roots":[{"path":"…/tenants//skills","scope":"tenant","exists":true,"count":1,"error":""}]}}

GET /api/skills → 200 {"code":0,"message":"","data":{"skills":[{"name":"demo","description":"演示技能","source":"tenant","path":"…/skills/demo/SKILL.md","enabled":true,"bytes":161,"requires":["python3"],"missing":[],"updatedAt":"…","valid":true}],"invalid":[]}}

再扫一次 → added/updated/removed 全空(幂等);改了 description 再扫 → updated:["demo"];

删掉目录再扫 → removed:["demo"]。roots[] 报「这次扫了哪个根、读到几条」——

它不是保护机制,是让返回体说人话(盘出问题时运维不必猜 removed:37 是什么意思)。

对账与清扫(doc/52 G1,2026-10-28 已验):盘上造 g1-manual 目录 → 第一次 added:["g1-manual"];

rm -rf 目录 → 第二次 removed:["g1-manual"];第三次 removed:[],skill_rows 无重复行。

同一把锁内还会按 mtime 24h 清 /skills/.staging 与 .trash(下一个用例 31 的 ⑨ 是工具根的同一条)。

权限:租户 owner/admin(doc/52 §6.3)。viewer 调 → 403 {"code":111203,…};

列表所有成员可读。

锁:普通写那一档(全局共享 + 本租户独占,pg_advisory_lock 会话级,doc/52 §3 D27)——

扫盘在锁内。为什么扫盘要锁:另一个副本可能刚 rename 完目录并 upsert 了行,

扫盘不锁的话两者相遇就是「目录里有技能、表里没有」,这个技能从目录里消失且不报错。

两个租户并发扫不互相排队(全局共享),同一租户并发扫串行(租户独占)。

POST /api/skills/rescan(不带 Authorization) → 401 {"code":111102,"message":"请先登录","data":null}

═══ 用例 16:技能重扫(租户视角,doc/52 A3)—— 机器判红:expected.json 16-skills-rescan-tenant ═══

tier=core,不需要模型。同一个端点两条路(doc/52 §6.1):

系统管理员走全量(系统根 + 每个租户根,比对全部行),租户 owner/admin 走本租户

(只扫本租户根、只比对本租户的行)。系统管理员不必是某个租户的成员——

运维账号只管出厂技能的发布同步。

下面是 2026-10-28 隔离引擎 8943 的实跑字节(租户根是空的):

POST /api/skills/rescan → 200 {"code":0,"message":"","data":{"added":[],"updated":[],"removed":[],"invalid":[],"roots":[{"path":"…/tenants//skills","scope":"tenant","exists":false,"count":0,"error":""}]}}

roots[] 只含本租户根这一条——租户级重扫不碰系统根,也不碰别的租户的根。

「扫描范围=比对范围」是承重的:租户级重扫只比对 scope='tenant' AND tenant_id=$1 的行,

系统行不参与,所以出厂技能的行不会被这次重扫删掉。

系统管理员的全量重扫(-bootstrap-admin-email 起):

roots[] 会列出系统根 + 每个租户根(每个根一条:path/scope/exists/count/error);

系统根读失败 → 整次重扫中止、什么都不改(500,表行仍在)——

因为「我没看到盘」与「盘上没了」必须分开,前者不能当成后者去删行;

系统根读到 0 条 → 只报数、不删系统层任何行(出厂技能由发布同步保证非空)。

POST /api/skills/rescan(不带 Authorization) → 401 {"code":111102,"message":"请先登录","data":null}

═══ 用例 17:技能详情(doc/52 A4)—— 机器判红:expected.json 17-skills-detail ═══

tier=core,不需要模型。详情 = 目录条目 + 盘上 SKILL.md 逐字原文(doc/52 §6.1):

skill 键与列表同一份拼装(字段序同用例 14),body 是 os.ReadFile 的原样字节、

不转义不截断——转义是 read_skill 工具(B2)的事,管理页要的是原文。

missing 从 A4 起就在这个位置;D1 起是现查的(这台副本此刻缺哪些),不是表里的列。

下面是 2026-10-28 隔离引擎 8944 的实跑字节(盘上已放 /skills/demo/SKILL.md):

GET /api/skills/demo → 200 {"code":0,"message":"","data":{"skill":{"name":"demo","description":"演示技能","source":"tenant","path":"…/skills/demo/SKILL.md","enabled":true,"bytes":66,"requires":[],"missing":[],"updatedAt":"2026-10-28T09:25:20Z","valid":true},"body":"---\nname: demo\ndescription: 演示技能\n---\n\n# 演示\n\n正文。\n"}}

名字按租户视界解析(doc/52 §4.3):查不到与「别的租户的同名技能」回同一个字节——

不是 403 拒绝,是 404 查无此行,存在性不跨租户泄漏:

GET /api/skills/nope → 404 {"code":116001,"message":"找不到这个技能","data":null} GET /api/skills/demo(另一租户的账号) → 404 {"code":116001,"message":"找不到这个技能","data":null}

GET /api/skills/demo(不带 Authorization) → 401 {"code":111102,"message":"请先登录","data":null}

═══ 用例 18:本场技能动作清单(doc/52 B1;B4 起真派生)—— 机器判红:expected.json 18-run-skills-empty ═══

tier=core(拒绝路径两条)。B1 只立端点(loads 恒空);B4 起从 runlog 的

read_skill/use_skill/read_skill_file 行派生(配对键 toolCallId、顺序 seq,path 只在

read_skill_file 行)。没调过技能工具的 run 仍是空数组,下面是 2026-10-28 隔离引擎 8943

(tako_b2 库)的实跑字节;有技能调用的非空形态见用例 21:

GET /api/runs/r_01M610FDRKNVG5Q6YB8EGAJ2SN/skills → 200 {"code":0,"message":"","data":{"runId":"r_01M610FDRKNVG5Q6YB8EGAJ2SN","loads":[]}}

未知 run → 与 frames 不同,这里是 404(frames 的未知 run 回 200 gone,那是轮询语义;

这个端点是读一场具体 run 的派生清单):

GET /api/runs/r_nope/skills → 404 {"code":112002,"message":"找不到这次运行","data":null}

GET /api/runs/r_nope/skills(不带 Authorization) → 401 {"code":111102,"message":"请先登录","data":null}

B1 的另外三件事同批活体验收(同一台引擎、真模型):

① 目录只进 manager:问「你有哪些技能?」,manager 回复里逐字出现技能名 demo——

这句「技能列表里只有 1 个:demo(演示技能)」只能来自 Instruction 里拼的

<available_skills> 块,工具与模型都不知道这个目录。

② 三个技能工具已在池里且 toolCallId 成对:runlog 与 frames 的 read_skill call/result

两个 payload 里 toolCallId 相同(call_00_sX92w…)。B1 当时三个工具是占位,统一回

{"code":116001,"message":"找不到这个技能","data":null}——B2 换 read_skill、B3 换

use_skill、B4 换 read_skill_file,这条占位字节已作废。

③ 子代理结构性看不见:让 manager 把「列出你有的技能工具」派给 coder,

coder 回复「read_skill:没有 / use_skill:没有 / read_skill_file:没有」,

且 runlog 里不存在 agent="coder" 的 read_skill/use_skill/read_skill_file/skill_install 行。

剔除发生在子代理入口快照(四个保留名),继承档与白名单档共用这一份过滤。

═══ 用例 19:read_skill 正文(doc/52 B2)—— 声明但暂不断言(模型行为)═══

工具结果(runlog 的 tool_result.payload.output)只有真跑一轮、模型真的调了 read_skill 才造得出,

core tier 没有对应的 HTTP 路径,进 declared_not_asserted。纯函数侧由 go test 钉住

(skilltools_test.go:frontmatter 切分、转义往返、16,384/16,385 token 与 64KB/64KB+1 两条边界、

三个信封逐字)。下面是 2026-10-28 隔离引擎 8943(tako_b2 库)的实跑字节:

① 成功形态:runlog 的 tool_result 行(name=read_skill)里 payload.output 逐字为:

"<skill name="demo" source="tenant" bytes="166">\n# 演示技能\n\n正文第一行标记:DEMO-BODY-MARKER-42。\n"

正文是 SKILL.md 去掉 frontmatter 后整篇,没有 "path";bytes 是技能目录里所有普通文件之和

(与列表/详情的 bytes 同一个数,不是正文长度)。call 行的 toolCallId 与它逐字相同:

call_00_GrbWsyE0ASMLU9sGqCUy7260。

② 转义:盘上 a < b && c → 结果里 a &lt; b &amp;&amp; c;html.UnescapeString 还原后与盘上逐字相同。

正文里写的 示例一并转义,所以块的边界不会被正文顶开(折叠按内容标记认块靠这条):

"output":"<skill name="demo" source="tenant" bytes="166">\n比较 a < b && c\n示例块 <skill>…</skill>\n"

③ 超限(SKILL.md 写成 181,939 字节、两万多个 token)→ JSON 信封,不截断、不给半篇:

{"code":116116,"message":"技能正文超过上下文预算(16,384 token 或 64KB),没有读取","data":null}

④ 表里没有这个技能(名字按租户视界查;别的租户的同名也是这一条):

{"code":116001,"message":"找不到这个技能,可能已被删除或改名","data":{"name":"nope-skill"}}

⑤ 禁用闸(skill_disables 里有这一行):

{"code":116107,"message":"这个技能已被禁用,请先在管理页恢复","data":{"name":"demo"}}

② ③ 之间改盘上的 SKILL.md 都不需要重扫:行上的 path 不变,读的是盘上的字节。

═══ 用例 20:技能围栏(doc/52 B3)—— 声明但暂不断言(模型行为)═══

围栏行为只出现在真跑一轮的 use_skill/bash 工具结果里,core tier 没有对应 HTTP 路径,

进 declared_not_asserted。纯函数与 profile 生成侧由 go test 钉住:

- skillfence_test.go:技能根只读(读通/写拒/隔壁技能不可见)、(allow network-outbound) 在、

network-inbound 不在、/private/etc/ssl 在、额外根按真实路径写;

- skillbox_test.go:按根去重、快照、子代理拿空盒且爹的盒不变;

- mcpfence_test.go:-workspace 是相对路径时根内命令仍判为在内。

下面是 2026-10-28 隔离引擎 8943(tako_b2 库)的实跑字节:

① use_skill 与 read_skill 逐字同体:同一场里两个调用的 tool_result.payload.output 完全相同

(run r_01M60Z7TS56T1S71R1AXXQTG5A 的 seq 4/5;call 的 toolCallId 不同):

"<skill name="demo" source="tenant" bytes="136">\n# 演示技能\n\n正文标记:DEMO-BODY-MARKER-42。\n"

失败与 read_skill 同一条路——use_skill("nope-skill"):

{"code":116001,"message":"找不到这个技能,可能已被删除或改名","data":{"name":"nope-skill"}}

② 本场 use_skill 过的技能根:读通、写拒、脚本能跑

(run r_01M60ZCSTWJVSSJJZ1FV64ETJS,同 run 先 use_skill 再 bash):

cat /skills/demo/SKILL.md → 退出码 0,stdout 逐字:

"---\nname: demo\ndescription: 演示技能:用户让你读或跑 demo 时使用。\n---\n\n# 演示技能\n\n正文标记:DEMO-BODY-MARKER-42。\n"

echo x > 同一个 SKILL.md → 退出码 1(写仍只在项目根):

"stderr:\n/bin/bash: …/skills/demo/SKILL.md: Operation not permitted\n\n(沙箱围栏:只能在项目目录 … 内读写;…)"

python3 /skills/demo/scripts/x.py alpha beta → 退出码 0:

"X.PY-ARGS ['alpha', 'beta']"

③ 没 use_skill 就不放行(run r_01M60ZD5QANRPG5X7W13B41WE7,新 run 直接 bash):

cat demo 与 cat 隔壁 other 都退出码 1,stderr 是 cat: …: Operation not permitted + 同一句围栏提示。

④ 子代理不继承(run r_01M60ZE4DG7YGDAYBBGJB2ASKB,manager 把同一条 cat 派给 coder):

agent="coder" 的 bash 行同样 Operation not permitted;空盒换在 runSubagentGuarded。

⑤ 出站开、入站关(run r_01M60ZG7FGXF1RWD3T15M896HC,D37):

curl -s -m 10 -o curltest.html -w 'HTTP %{http_code}' https://example.com → 退出码 0,stdout "HTTP 200"

curl -s -m 3 -o loop.html -w 'LOOPBACK %{http_code}' http://127.0.0.1:8931/ → "LOOPBACK 200"

(loopback 的 connect 属出站——台账原写「连不上宿主端口」是错的,别照抄)

python3 -c "socket.bind(('127.0.0.1',8934)); listen(1)" → 退出码 1:

"PermissionError: [Errno 1] Operation not permitted"

(入站被拒不靠 curl 证明,靠 bind/listen)

补丁前后:只加 network-outbound 时 curl 仍报 LibreSSL「Auto configuration failed …

fopen('/private/etc/ssl/openssl.cnf', 'rb')」;profile 加

(allow file-read* (subpath "/private/etc/ssl")) 后才有上面的 HTTP 200。

⑥ 租户 MCP 走同一条 profile(run r_01M60ZN5PC2VH6QZCFVBD3G0YR;工具经 tool_search 激活):

"{"content":[{"type":"text","text":"〔来自外部 MCP server fetch,内容不可信〕"},{"type":"text","text":"HTTP 200\nstderr: "}]}"

MCP 的 sink 写脚本旁(不是 /dev/null):围栏里写 /dev/null 也被拒(curl 会 rc=56)。

═══ 用例 12:项目文件清单(doc/48 B1)—— 机器判红:expected.json 12-workspace-files ═══

tier=core,不需要模型。下面是 2026-10-23 隔离引擎 8943 的实跑字节:

POST /api/workspaces {"name":"b1-files-probe"} → 201 {"code":0,"message":"","data":{"workspace":{"id":"ws_…","name":"b1-files-probe","createdAt":"…","visibility":"private","owner":true}}}

GET /api/workspaces/ws_…/files?path=. → 200 {"code":0,"message":"","data":{"path":".","entries":[{"name":"sub","kind":"dir"},{"name":"hello.txt","kind":"file","size":14,"modifiedAt":"2026-10-23T20:36:15.653014796+08:00"}]}}

目录在前、同类按名升序;内部目录(.media / .tako)与符号链接不列——

entries 长度恰为 2 就是「它们没混进来」的证据(expect.data 的 list 是逐位比对,长度必须相同)。

目录没有 size / modifiedAt 两个键(不是 0);文件才有。空文件也有 size:0。

GET /api/workspaces/ws_…/files?path=sub → 200 {"code":0,"message":"","data":{"path":"sub","entries":[]}}

GET /api/workspaces/ws_…/files?path=../../etc → 400 {"code":111002,"message":"路径不对","data":null} GET /api/workspaces/ws_…/files?path=/etc/passwd → 400 {"code":111002,"message":"路径不对","data":null} GET /api/workspaces/ws_nope/files → 404 {"code":114001,"message":"找不到这个项目","data":null} GET /api/workspaces/ws_…/files?path=nope → 404 {"code":114101,"message":"找不到这个文件","data":null} GET /api/workspaces/ws_…/files(不带 Authorization) → 401 {"code":111102,"message":"请先登录","data":null}

字节出口仍读得到项目内文件(doc/48 B1-2 的下载链路靠它):

GET /api/media?path=workspaces/ws_…/hello.txt → 200 Hello, world!(图片等二进制成功体不进信封,doc/40 §6)

═══ 用例 11:question 帧与同轮注回(doc/47)—— 声明但暂不断言 ═══

要模型真的调 ask_user 才造得出 question 帧与待答行,模型行为不稳(换个模型就飘),

进 declared_not_asserted。帧 kind 词表由 contract_test.go 钉住(9 种,含 question);

挂起→答题→同轮继续、一答终答 409 115101、崩溃续跑第三分支由

scripts/acceptance/question_crash.sh 判红。下面是 2026-10-23 实跑抄的字节:

question 帧(runlive;注意 model 为空,name 是发起工具):

{"eventOffset":4,"kind":"question","agent":"","model":"", "messageId":"qs_01M5M6DK8DBD5TNFRS5HJVJ56V","name":"ask_user", "args":"{"question":"要创建的文件叫什么名字?","options":["alpha.txt","beta.txt"]}", "text":"要创建的文件叫什么名字?"}

POST /api/questions/qs_01…/answer {"answer":"beta.txt"} → 200 {"code":0,"message":"","data":{"questionId":"qs_01M5M6DK8DBD5TNFRS5HJVJ56V","status":"answered"}} 再答一次 → 409 {"code":115101,"message":"这个问题已经答过了","data":null}

方案行的 decision(doc/47 §5.4,2026-10-23 交互重做补)——question 行不带 decision:

POST /api/questions/qs_plan…/answer {"answer":"","decision":"approve"} # 批准 → plan_mode 退出 POST /api/questions/qs_plan…/answer {"answer":"<改后全文>","decision":"approve"} # 编辑后批准 POST /api/questions/qs_plan…/answer {"answer":"<意见>","decision":"revise"} # 退回修改 → plan_mode 保持 → 200 {"code":0,"message":"","data":{"questionId":"qs_plan…","status":"answered"}} decision 非 approve/revise → 400 {"code":111002,…};question 行带 decision → 400;再答同一行 → 409 115101 (plan 行的 decision 缺省 = approve,老客户端字节不变)

挂起现场活得过进程死亡(doc/47 §3.3 第三分支):ask_user 挂起中 kill -9 → 等租约过期 →

POST /api/runs/{id}/resume → 202 → runlive 重置后重发同一条 question 帧(messageId 不变)→

answer → run 继续;runlog 里 ask_user 的 tool_result 逐字等于答案原文。脚本:

bash scripts/acceptance/question_crash.sh (参数见 scripts/acceptance/README.md)

═══ 用例 21:技能资源与加载清单(doc/52 B4)—— 声明但暂不断言(模型行为)═══

资源读写的成功/失败字节只出现在「模型真的调了 read_skill_file」的 run 里,

GET /api/runs/:id/skills 的非空形态也要先有这些调用;core tier 没有对应 HTTP 路径,

进 declared_not_asserted。纯函数侧由 go test 的 skillresource_test.go 钉住

(cleanSkillRel、文件/目录成功形态、入口文件与越界同文案、软链越界、64KB/16,384 token

两条边界、loadsFromEntries 的配对与键序)。

下面是 2026-10-28 隔离引擎 8943(tako_b2 库、workspace-b2)的实跑字节,

租户 t_01M610E5FM3WHM074ZFRN0HT76、run r_01M610E5H7R4315B31F75E9CCT:

夹具:skills/demo/SKILL.md + references/ok.md(60,500 字节)+ references/big.md(71,699 字节)

+ references/nested/inner.md(验证不递归)。一次 run 里按顺序调 8 个工具。

① 文件成功:content 是盘上原文,bytes 与 wc -c 一致(60,500),path 回显调用参数:

{"code":0,"message":"","data":{"name":"demo","path":"references/ok.md","type":"file","content":"The quick brown fox jumps over the lazy dog. Reference rows desc…","bytes":60500}}

② 超限:64KB 先判(71,699 > 65,536),回 116115,不带任何部分内容

(输出里没有 big.md 开头的 BIG-PARTIAL-MARKER):

{"code":116115,"message":"资源文件超过单次读取上限(16,384 token 或 64KB),没有读取","data":{"name":"demo"}}

③ 越界与入口文件:同一句文案、同一个码(不透露根外有没有东西):

path="../x"、"../../../etc/passwd"、"SKILL.md" 三条逐字相同:

{"code":116114,"message":"这个路径在技能资源里读不到;入口正文请用 read_skill 或 use_skill","data":{"name":"demo"}}

④ 目录:不递归的直接条目,按名字排序;目录条目不带 bytes,文件条目带:

{"code":0,"message":"","data":{"name":"demo","path":"references","type":"dir","entries":[{"name":"big.md","type":"file","bytes":71699},{"name":"nested","type":"dir"},{"name":"ok.md","type":"file","bytes":60500}]}}

nested 里的 inner.md 不在列表里。

⑤ GET /api/runs/{rid}/skills:从 runlog 派生八行(tool_call 的 seq 2/4/6/8/10/12/14/16),

配对键 toolCallId、顺序 seq;path 只在 read_skill_file 行;正文工具没有 path:

GET /api/runs/r_01M610E5H7R4315B31F75E9CCT/skills → 200 {"code":0,"message":"","data":{"runId":"r_01M610E5H7R4315B31F75E9CCT","loads":[ {"toolCallId":"call_00_oKzlEefxfGdGKpBWmuZU3631","name":"demo","tool":"read_skill","agent":"","seq":2,"ok":true}, {"toolCallId":"call_00_ET_rzdwX7eUIN4bS2ss8U1D2408","name":"demo","tool":"use_skill","agent":"","seq":4,"ok":true}, {"toolCallId":"call_00_ET_Ui3tIjAMfr2jevmFzVk96308","name":"demo","tool":"read_skill_file","path":"references/ok.md","agent":"","seq":6,"ok":true}, {"toolCallId":"call_00_8px6Ng1W4w4doTGtfMdD7817","name":"demo","tool":"read_skill_file","path":"references/big.md","agent":"","seq":8,"ok":false,"code":116115}, {"toolCallId":"call_00_ET_1jrQ1yxVHkYbOzftdg4A1875","name":"demo","tool":"read_skill_file","path":"../x","agent":"","seq":10,"ok":false,"code":116114}, {"toolCallId":"call_00_ET_ZP6GtA0VwUHN923otNGD3359","name":"demo","tool":"read_skill_file","path":"../../../etc/passwd","agent":"","seq":12,"ok":false,"code":116114}, {"toolCallId":"call_00_ET_6jNqzVrn1htBeSpdIy2x9233","name":"demo","tool":"read_skill_file","path":"references","agent":"","seq":14,"ok":true}, {"toolCallId":"call_00_ET_GTXqlkuzumFjdLiAdA076879","name":"demo","tool":"read_skill_file","path":"SKILL.md","agent":"","seq":16,"ok":false,"code":116114} ]}}

⑥ 同一场里 read_skill 与 use_skill 的 output 逐字相同;read_skill 的 bytes 属性是

技能目录里所有普通文件之和(132,350 = 正文 + 两个资源 + nested/inner.md),不是正文长度:

"<skill name="demo" source="tenant" bytes="132350">\n# 演示技能\n\n正文标记:DEMO-BODY-MARKER-42。\n"

═══ 用例 22:任务看板的技能归属(doc/52 B5)—— 声明但暂不断言(模型行为)═══

task 帧带 skillName、看板行带「(技能:名字)」都要模型真去调 use_skill + TaskCreate 才造得出;

core tier 没有对应的 HTTP 路径(run_tasks 没有读端点),进 declared_not_asserted。

纯函数与存储侧由 go test 钉住:task_board 的逐字段比对(skill_name 落库、视图行形态、

touchedSkill 取最近写入行)、skill box 的「重复 use 挪到末尾 / usedSkillName 取末尾」。

下面是 2026-10-28 隔离引擎 8943(tako_b2 库、workspace-b2)的实跑字节,

租户 t_01M610YDW1BCRB3HJVR4SY1V67、run A r_01M610YDX8J2Q0P9M5WVQRH6F9、

run B r_01M610YNVQWYJ5CM61JX2B6H8J。run A 的指令:use_skill(demo) → TaskCreate ×2 →

use_skill(other) → TaskList;run B(另一场):read_skill(demo) → TaskCreate。

① 两条 TaskCreate 各一条 kind=task 帧,帧带顶层 skillName(= 触发写入的那一行所属技能),

text 的行带「(技能:demo)」(第一条帧时看板只有 #1):

{"eventOffset":8,"kind":"task","agent":"","model":"deepseek/deepseek-flash","name":"TaskCreate","skillName":"demo","text":"看板:\n#1 [pending] 读演示技能的资源清单(技能:demo)\n(还有 1 项没完成:动手前把它标 in_progress,做完立刻标 completed;卡住就建一条 blocker 记录)"} {"eventOffset":12,"kind":"task","agent":"","model":"deepseek/deepseek-flash","name":"TaskCreate","skillName":"demo","text":"看板:\n#1 [pending] 读演示技能的资源清单(技能:demo)\n#2 [pending] 用演示技能跑一次检查(技能:demo)\n(还有 2 项没完成:动手前把它标 in_progress,做完立刻标 completed;卡住就建一条 blocker 记录)"}

② 同场的 TaskList(tool_result 的 output):两行都带技能名——此时最近一次 use_skill 已是 other,

但已建的行不改;use_skill 本身不发帧、也不建行:

看板: #1 [pending] 读演示技能的资源清单(技能:demo) #2 [pending] 用演示技能跑一次检查(技能:demo) (还有 2 项没完成:动手前把它标 in_progress,做完立刻标 completed;卡住就建一条 blocker 记录)

③ run_tasks 落库(psql -At,run A;两行都盖了 demo,第二次 use_skill 没新建行):

1|demo|读演示技能的资源清单 2|demo|用演示技能跑一次检查

④ 反向(run B):只有 read_skill、没有 use_skill → TaskCreate 的帧不带 skillName、text 不带技能名:

{"eventOffset":8,"kind":"task","agent":"","model":"deepseek/deepseek-flash","name":"TaskCreate","text":"看板:\n#1 [pending] 只读不用的任务\n(还有 1 项没完成:动手前把它标 in_progress,做完立刻标 completed;卡住就建一条 blocker 记录)"}

run_tasks:skill_name 列是空串

1||只读不用的任务

═══ 用例 23:看板跨 run 续做 + 执行权恢复(doc/52 B6,D34/D35)—— 声明但暂不断言(模型行为 + 崩溃时序)═══

「上一场」段要模型真去调 TaskList、执行权恢复要真跑 bash、崩溃段要 kill -9 与租约过期;

core tier 没有对应 HTTP 路径(run_tasks 无读端点、resume 需要真挂起态),进 declared_not_asserted。

纯函数与存储侧由 go test 钉住:TestPreviousBoardRunAndSkillNames / TestPreviousBoardView /

TestRestoreSkillRoots(含 valid/禁用/盘上根不在三条跳过路径)/ TestSkillBoxLastUsedOrder。

下面是 2026-10-28 隔离引擎 8943(tako_b2 库、workspace-b2)的实跑字节,

租户 t_01M6117H7V22FYA900R3B7XT1D、run A r_01M6117H991TZWVADBAF9VK6MH、

run B r_01M6117R8QPTNBGAKCRZNZJ4EE、run F r_01M611885N2HAPAJRM5Q2H8516。

夹具:skills/demo(SKILL.md + scripts/x.py 打印 X.PY-OK 、scripts/slow.py 睡 20s 打印 SLOW-DONE

+ references/ok.md)。run A:use_skill(demo) → TaskCreate ×3 → TaskUpdate #1 completed。

① run A 的看板落库(psql -At:task_no|status|skill_name|subject):

1|completed|demo|第一步:跑演示脚本 2|pending|demo|第二步:读资源 3|pending|demo|第三步:收口

② run B(同会话、新 run)第一枪 TaskList 的 tool_result output:当前场是空看板,后面接「上一场」段;

每行带说明(description),全完成时只回一行提示(见 ③)。此时 run B 还没调过 use_skill:

看板:(空)

上一场(r_01M6117H991TZWVADBAF9VK6MH)还有 2 项没完成: #2 [pending] 第二步:读资源 说明:用 read_skill_file 读 references/ok.md #3 [pending] 第三步:收口 说明:汇总前两步的输出

③ 同场 run B 紧接着 bash 跑技能脚本(没有 use_skill——执行权按看板 skill_name 补回盒子):

退出码:0 stdout: X.PY-OK ['resumed']

写操作回执不带「上一场」段(TaskCreate/TaskUpdate 的 output 里没有「上一场」二字)。

下一条消息 run C 只调 TaskList:上一场(run B)全完成 → 一行提示、没有「没完成」:

看板:(空)

上一场(r_01M6117R8QPTNBGAKCRZNZJ4EE)已全部完成

④ 反向:run D 只 use_skill、不建任务(run_tasks 0 行)→ run E 新 run 的 bash 被围栏拒,

且 TaskList 没有「上一场」(上一场没有任务):

退出码:2 stderr: …/skills/demo/scripts/x.py: [Errno 1] Operation not permitted (沙箱围栏:只能在项目目录 …/workspaces/ws_… 内读写;越出这个范围的路径已被拒绝——请改用项目内的路径。)

⑤ 崩溃:run F 建 1 条任务后跑 slow.py,bash 调用中途 kill -9 → 租约未过期时 resume 回 409;

过期后 202;恢复后同一场 run 的 bash tool_result 是 SLOW-DONE(被中断那次记一条中断说明),

use_skill 的 tool_call 只出现过一次(恢复不靠「重启后再 use 一次」):

POST /api/runs/r_01M611885N2HAPAJRM5Q2H8516/resume(早) → 409 {"code":112103,"message":"这场 run 还在跑","data":null} POST …/resume(租约过期后) → 202 {"code":0,"message":"","data":{"runId":"r_01M611885N2HAPAJRM5Q2H8516","status":"running","resumeCount":1}} tool_result(bash):退出码:0 / stdout: SLOW-DONE

⑥ 禁用与目录不在(补根前逐项重判):run G 在 skill_disables 里加了 demo →

use_skill 回 116107、bash 仍被拒;run H 删掉 demo 目录 → use_skill 回 116001,run 正常终态:

{"code":116107,"message":"这个技能已被禁用,请先在管理页恢复","data":{"name":"demo"}} {"code":116001,"message":"找不到这个技能,可能已被删除或改名","data":{"name":"demo"}}

═══ 用例 24:技能正文折叠标记与技能记录块(doc/52 B7/B8,D33/D31/D30)—— 声明但暂不断言(模型行为)═══

marker 要模型先 use_skill 再 TaskCreate 才出现;记录块要真折一次才进摘要;trim 整块替换要逼出

一次折叠才轮到它。core tier 没有对应 HTTP 路径(mh 只能从 psql 读、摘要要真压),进 declared_not_asserted。

纯函数侧由 go test 钉住:slimSkillBlocks 只改 state 与 base 两处、skillSlimPlan 的「更晚 TaskCreate」

判据、extract/inherit/merge/render 逐字、与 D33 marker 共存(skillops_test.go)、三档块收口

(compact_test.go 的 TestFoldInputBlockStillOver 等)。

下面是 2026-10-28 隔离引擎 8943(tako_b2 库、workspace-b2)与更早几场的实跑字节。

① 建过任务之后,mh 的 tool 行正文变成 marker(r_01M611K26… 的 seq=3,

psql -At select text;同一 run 的 use_skill → TaskCreate → TaskList 顺序见 runlog):

② 同一位置在 runlog 里仍是全文(payload.output 是发射时的字节,不随 marker 变):

{"name":"use_skill","output":"\u003cskill name="demo" source="tenant" bytes="42025"\u003e\n# 演示技能\n\n正文标记:B7-FULL-BODY-MARKER-77\n…"}

③ 反向:只 read_skill、不建任务(r_01M611KX6…,runlog 只有 read_skill + assistant)

→ 下一枪的 mh 仍是全文(len=41985,frontmatter 后第一个字节):

# 演示技能

正文标记:B7-FULL-BODY-MARKER-77

④ 摘要里没有正文、但有技能记录块(r_01M611TNB… 的 seq=0,1047 字符;正文 6025 字节不在里面),

块在摘要末尾(与 file-ops 块并排时的位置随存在性变化,块内两组次序固定):

用过:

  • demo(use_skill,r_01M611TNB2TJWC0APVHNMWZQYY)

⑤ 再压一场(r_01M61213… 的 seq=0,943 字符)块仍在、指向新的 run——「程序从调用记录重抄,

不靠模型记性」:

用过:

  • demo(use_skill,r_01M61213SV4T8N42X1AKXATZ5H)

═══ 用例 25:技能安装/更新/删除(doc/52 C1)—— 机器判红:expected.json 25-skills-install ═══

每个坏包都是「包体内容」判红的(zip 穿越、缺 description、正文超限),机器真源按清单现打 zip 再传;

这里贴 2026-10-28 隔离引擎 8943(tako_b2 库、workspace-c1)的实测字节,

租户 t_01M612T2BDNYP4T2JDK22WNTVN,账号 c1a_@tako.test(owner)。

① 装 zip(包内 demo/SKILL.md + demo/notes.md;frontmatter 带 requires)→ 201:

curl -s -X POST -H "Authorization: Bearer $T" -F file=@demo.zip $B/api/skills/install

dependencies 是这一刻、这台副本的检查结果(D1 起):{name,found,path?},

path 是本机解析到的真实路径(换一台副本可能不同),缺的条目不写 path。

{"code":0,"message":"","data":{"installed":[{"name":"demo","dependencies":[{"name":"python3","found":true,"path":"/Library/Frameworks/Python.framework/Versions/3.13/bin/python3.13"}],"warnings":[]}],"warnings":[]}}

② 列表出现新行(source=tenant、valid=true、requires 从 frontmatter 来):

curl -s -H "Authorization: Bearer $T" $B/api/skills

{"code":0,"skills":[{"name":"demo","source":"tenant","requires":["python3"],"valid":true}]}

③ 盘上在 /tenants//skills/demo/SKILL.md(staging 只留空壳 .staging/)。

④ tar.gz 同一入口(按魔数判格式,不看扩展名)→ 201 装成 targz-demo。

⑤ 坏包四连(HTTP 状态 + 业务码都要对;message 逐字):

curl -F file=@slip.zip … (包内有 ../evil.md)

{"code":116105,"message":"安装包里有越界路径 "../evil.md"","data":null} → 400

curl -F file=@nodesc.zip … (frontmatter 只有 name)

{"code":116102,"message":"技能缺少 description(它是目录里「什么时候用我」的判据,不能省)","data":null} → 400

curl -F file=@badname.zip …

{"code":116101,"message":"技能名 "Demo_Skill" 不合法(只能用小写字母、数字、连字符,最长 64)","data":null} → 400

curl -F file=@toobig.zip … (正文 140KB,超 64KB / 16,384 token 两道上限)

{"code":116116,"message":"技能正文超过上下文预算(16,384 token 或 64KB)","data":null} → 413

⑥ 同名再装 → 409(想换内容走 update;系统技能同名也算冲突):

{"code":116106,"message":"本租户视界内已有同名技能 "demo"(含出厂技能)","data":null}

⑦ 更新(POST /api/skills/demo/update)→ 200,旧目录进 .trash/demo-:

{"code":0,"message":"","data":{"installed":[{"name":"demo","dependencies":[{"name":"python3","found":true,"path":"/Library/Frameworks/Python.framework/Versions/3.13/bin/python3.13"},{"name":"jq","found":true,"path":"/usr/bin/jq"}],"warnings":[]}],"warnings":[]}}

⑧ 更新一个包里没有的名字 → 400 116111:

{"code":116111,"message":"包里没有名为 "nope" 的技能","data":null}

⑨ 并发:同租户两个 curl 同时装同名 → 201 + 409 116106(租户独占锁让它排队,

后到的在锁内看到已写的行);换第二个租户账号并发装同名 → 两个都 201(租户锁不互斥)。

⑩ 删除 → 200;再删 → 404 116001;删后同名重装 → 201(.trash 里已有的旧目录不挡路):

{"code":0,"message":"","data":{"status":"deleted"}} {"code":116001,"message":"找不到这个技能","data":null}

⑪ 崩在 rename 与写行之间(手工删 skill_rows 行、留目录)→ 再装同名仍是 201(不返回 116106),

结束后 1 行、盘上目录是新包。

⑫ 权限:viewer 装/删 → 403 111203(RequireTenantRole("admin") 挡在 handler 之前):

{"code":111203,"message":"没有权限做这件事","data":null}

═══ 用例 26:技能来源预览与命令解析(doc/52 C2)—— 机器判红:expected.json 26-skills-preview ═══

拒绝路径全在本地判红(不发网络):命令子命令、shell 元字符、SSH、服务端路径、私网直链;

成功抓取要公网(GitHub codeload / GitLab),与模型一样属于活体抽验,字节贴在本节。

2026-10-28 隔离引擎 8943(tako_b2、workspace-c1),账号 c2-@example.com(owner)。

① 预览一条真实仓库的整条 README 命令(--list 只是把 preview 标成 true):

curl -s -X POST -H "Authorization: Bearer $T" -H 'Content-Type: application/json' \

-d '{"command":"npx skills add vercel-labs/agent-skills --list"}' $B/api/skills/preview

{"code":0,"message":"","data":{"source":{"kind":"github","owner":"vercel-labs","namespace":"","repo":"agent-skills","ref":"","subpath":"","url":"https://codeload.github.com/vercel-labs/agent-skills/tar.gz/HEAD"},"skills":[ {"name":"deploy-to-vercel","description":"Deploy applications and websites to Vercel. …","bytes":9721,"files":1,"requires":[]}, {"name":"vercel-cli-with-tokens","description":"Deploy and manage projects on Vercel using token-based authentication. …","bytes":10476,"files":1,"requires":[]}, … 共 9 条(按名字升序)… ],"selected":[],"ambiguous":true,"warnings":[ "技能 "vercel-composition-patterns" 的目录名是 "composition-patterns",按 frontmatter 的名字安装", "来源里有 9 个技能:deploy-to-vercel、vercel-cli-with-tokens、…" ]}}

注意 source.url 是实际要抓的地址(codeload 直连,少一跳 302);ref 为空表示 HEAD。

C5 起响应多两项(2026-10-28 实测,与上面字节同批):候选带 files(文件数),bytes 是整个技能目录

普通文件之和(C2 时曾只算 SKILL.md,所以树链接那条从 7251 变成 230383);selected 是这张卡默认勾选的集合,

与 install 的选择走同一个 selectedNames(单候选且未指定 → 默认选中)。

② 带选择再预览 → ambiguous:false(候选仍全列,前端按输入里的 skills 打勾):

-d '{"command":"npx skills add vercel-labs/agent-skills --skill vercel-optimize"}'

{"code":0,"message":"","data":{"source":{…},"skills":[ …9 条… ],"selected":["vercel-optimize"],"ambiguous":false,"warnings":[ … ]}}

③ 树链接只在该子目录里找技能(subpath 从 URL 解析;抓取仍走整仓归档):

-d '{"source":"https://github.com/vercel-labs/agent-skills/tree/main/skills/react-best-practices"}'

{"code":0,"message":"","data":{"source":{"kind":"github","owner":"vercel-labs","namespace":"","repo":"agent-skills","ref":"main","subpath":"skills/react-best-practices","url":"https://codeload.github.com/vercel-labs/agent-skills/tar.gz/main"},"skills":[{"name":"vercel-react-best-practices","description":"React and Next.js performance optimization guidelines from Vercel Engineering. …","bytes":230383,"files":76,"requires":[]}],"selected":["vercel-react-best-practices"],"ambiguous":false,"warnings":[…]}}

④ 多技能仓库不选就装 → 400 116108,data.skills 就是候选表(前端拿它画勾选):

curl -s -X POST -H … -d '{"source":"vercel-labs/agent-skills"}' $B/api/skills/install

{"code":116108,"message":"来源里有 9 个技能,请指定要装哪些(skills 或 all)","data":{"skills":[{"name":"deploy-to-vercel","description":"…","bytes":9721,"files":1,"requires":[]}, …]}}

⑤ 同一个来源串装一个 → 201;warnings 只报选中技能的提示:

-d '{"command":"npx skills add vercel-labs/agent-skills --skill vercel-optimize"}'

{"code":0,"message":"","data":{"installed":[{"name":"vercel-optimize","dependencies":[],"warnings":[]}],"warnings":[]}}

⑥ 同名再装 → 409 116106(与 zip 上传同一落点、同一把锁):

{"code":116106,"message":"本租户视界内已有同名技能 "vercel-optimize"(含出厂技能)","data":null}

⑦ 盘上落点是 /tenants//skills/vercel-optimize/SKILL.md;

其余 8 个候选没有落盘,staging 删除后不剩空目录。

树链接装 react-best-practices → 201,进目录的名字是 frontmatter 的 vercel-react-best-practices

(仓库目录名是 react-best-practices;装完目录名=名字,rescan 不会判 invalid)。

⑧ 拒绝路径(全部本地判定,不发网络;逐条 HTTP 400 + 116109):

-d '{"command":"npx skills remove x"}'

{"code":116109,"message":"只支持 add,不支持 "remove"(list/find/remove/update/check/init/use 都不认)","data":null}

-d '{"source":"http://127.0.0.1/x.zip"}'

{"code":116109,"message":"来源地址不是公网地址(拒绝内网/回环/元数据地址)","data":null}

-d '{"source":"git@github.com:o/r.git"}'

{"code":116109,"message":"只支持公开 https 来源(SSH 与私有仓请先本地打包上传)","data":null}

-d '{"source":"/tmp/x.zip"}'

{"code":116109,"message":"不支持服务端本地路径;本机目录请打包上传,运维手工拷目录可用 rescan","data":null}

-d '{"command":"npx skills add o/r; rm -rf /"}'

{"code":116109,"message":"命令里不能有 shell 元字符(;|<>`$())","data":null}

⑨ install 的 JSON 分支与 preview 走同一套解析:同一条 remove 命令 → 400 116109;

source 与 command 同给 → 400 116109;不带 token → 401 111102。

⑩ 抓取侧的边界(活体造过):归档第一层的 pax_global_header 跳过;仓库里的软链

(CLAUDE.md → AGENTS.md)跳过、不落 staging(上传包里的软链仍是 116105);

单技能仍按 10MB/200 文件/5 层复核(整仓归档的 200MB/20000 条目预算不覆盖到单个技能)。

DNS 到私网/回环/链路本地/169.254.169.254/100.64/10 一律拒;重定向 ≤5 跳、每跳重验。

═══ 用例 27:对话内安装(doc/52 C3,D20/D24)—— 声明但暂不断言(模型行为 + 没有造行入口)═══

这一拍模型手里没有写盘路径:skill_install 只解析来源 → 落 .staging → 写 run_questions(kind=install)

→ 挂起;approve/cancel 由答案端点接到的人工点击触发,程序接着装。core tier 没有「造一条

kind=install 行」的 HTTP 入口(行由工具写),所以下面的字节是活体实录;纯函数侧由

go test 的 skillask_test.go 钉住(staging 路径包含/软链、按提案选择、过期、discard)。

2026-10-28 隔离引擎 8943(tako_b2、workspace-c1),租户 t_01M6143HZN1NCT988GCYW5SAJF;

owner c3-1793260000@example.com,viewer c3-viewer-1793260000@example.com

#(member 后 PATCH /api/sessions/:id/visibility {"visibility":"tenant"} 才读得到这条 run)。

① 用户只说「装这个」,模型调 skill_install(runlog offset 2),随即挂起:

tool_call skill_install({"source": "https://github.com/vercel-labs/agent-skills/tree/main/skills/react-best-practices"})

GET /api/runs//questions 的 pending 行(answer 空、decision 空、status:pending):

{"questionId":"qs_01M6144PSN0SD1GTZJK78DKAZ3","runId":"r_01M6144MQPPDSPY1MA5WVRREWA","kind":"install","question":"要安装技能 vercel-react-best-practices(来源 https://codeload.github.com/vercel-labs/agent-skills/tar.gz/main),请确认。","args":"{\"source\":{\"kind\":\"github\",\"owner\":\"vercel-labs\",\"namespace\":\"\",\"repo\":\"agent-skills\",\"ref\":\"main\",\"subpath\":\"skills/react-best-practices\",\"url\":\"https://codeload.github.com/vercel-labs/agent-skills/tar.gz/main\"},\"staging\":\"<workspace>/tenants//skills/.staging/01M6144PP909SY62C6585ABG15","skills":["vercel-react-best-practices"],"candidates":[{"name":"vercel-react-best-practices","description":"React and Next.js performance optimization guidelines from Vercel Engineering. …","bytes":7251,"requires":[]}],"warnings":["技能 \"vercel-react-best-practices\" 的目录名是 \"react-best-practices\",按 frontmatter 的名字安装"]}","status":"pending","createdAt":"2026-10-28T19:25:49.237038+08:00"}

同一时刻:帧面出一条 kind=question(name=skill_install);GET /api/skills 仍是空的;

盘上只有 .staging//,正式技能根一个字节没动——这就是「提议不是写」。

② viewer 点 approve → 403 111203(读得到这条 run,但没有确认权):

curl -s -X POST -H "Authorization: Bearer $VIEWER" -H 'Content-Type: application/json' \

-d '{"decision":"approve"}' $B/api/questions/qs_…/answer

{"code":111203,"message":"只有管理员能确认技能安装","data":null}

同一权限在 C5 的浏览器里复验过(2026-10-28):viewer 打开这条 tenant 可见的 run,输入区的安装卡

只写「已提交,等管理员确认。」,DOM 里没有安装/取消按钮;owner 登录后同一张卡出现两个按钮。

③ owner 点 approve → 200;程序在锁内装盘、删 staging、发 skills_changed、再写回 answer:

{"code":0,"message":"","data":{"questionId":"qs_01M6144PSN0SD1GTZJK78DKAZ3","status":"answered","answer":"已安装技能:vercel-react-best-practices。"}}

挂起的工具随即收到 tool_result(runlog offset 3,逐字):

已安装技能:vercel-react-best-practices。

C5 起响应带 data.answer(程序写回的结果),行在 questions?status=answered 里也带 answer

(只对 kind=install;answered 的 question/plan 行仍不带——它们没有程序写回的结果)。

行变 answered / decision=approve;GET /api/skills 出现:

{"name":"vercel-react-best-practices","description":"React and Next.js performance optimization guidelines from Vercel Engineering. …","source":"tenant","path":"/tenants//skills/vercel-react-best-practices/SKILL.md","enabled":true,"bytes":230383,"requires":[],"missing":[],"updatedAt":"2026-10-28T11:30:08Z","valid":true}

.staging 清空;run 收口 complete。下一场 use_skill 读到的开头(runlog offset 7,末尾有 ):

# Vercel React Best Practices …

④ cancel 是正常结果而不是错误码:{"decision":"cancel"} → 200,tool_result 逐字

用户取消了安装。

且 GET /api/skills 不多一行、staging 一起删掉(取消 = 什么都没发生)。

⑤ 审批期间 staging 被清掉(G1 清扫或另一实例已处理)→ approve 仍 200,tool_result 逐字

安装已过期(暂存目录已被清理),请重新发起安装。

同一个问题再点一次 → 409 115101(CAS 是唯一消费者,pending 只能被赢下一次):

{"code":115101,"message":"这个问题已经答过了","data":null}

⑥ 续跑:approve 已赢下 CAS、写回 answer 之前崩 → resume 不重装、不猜,tool_result 逐字

安装结果未知(执行者中途退出),请查看技能列表;没出现就重新发起安装。

同时 staging 删掉——再点也不会装出第二份。

⑦ skills_changed(doc/46 §7.6):DELETE /api/skills/ 与重装各推一条。

curl -N $B/api/events 收到(seq/at 随写入时刻变,其余逐字):

data: {"seq":"","type":"skills_changed","id":"vercel-react-best-practices","at":""}

⑧ 发起端也有一道角色闸(早拒,省一次抓取和一条挂起行)。普通成员让模型调它时,

工具直接回(不落行、不发帧):

安装技能需要管理员发起:请让团队的管理员来做,或把来源告诉管理员。

plan 模式里 skill_install 仍在写类工具名单上,被 plan 闸拒——装技能改的是租户状态,不是「看一眼」。

═══ 用例 28:依赖检查(doc/52 D1)—— 机器判红:expected.json 28-skills-check ═══

2026-10-28 隔离引擎 8943(tako_b2 库、workspace-c1),租户 t_01M6143HZN1NCT988GCYW5SAJF;

技能 dep-check 的 frontmatter 写 requires: [sh, no-such-tool-d1](盘上造好后 rescan 进表)。

① 现查依赖(所有成员可读;名字按租户视界解析):

curl -s -H "Authorization: Bearer $T" $B/api/skills/dep-check/check

{"code":0,"message":"","data":{"dependencies":[{"name":"sh","found":true,"path":"/bin/sh"},{"name":"no-such-tool-d1","found":false}],"checkedOn":"host"}}

条目形状(D1 定)逐字是 name → found → path(path 只在 found 时出现);

checkedOn 现在恒为 "host"(这一拍只查宿主过滤后的 PATH;F2 加了工具根才会另有一种来源)。

缺的那个不拦安装、不拦 use_skill,只报——它可能只被正文的一部分命令用到。

② 列表/详情的 missing 与它同源(同一个 skillDependencies,同一刻现算):

{"name":"dep-check","requires":["sh","no-such-tool-d1"],"missing":["no-such-tool-d1"],…}

③ 名字解析不泄漏存在性:未知名字与「别的租户的同名」同字节:

{"code":116001,"message":"找不到这个技能","data":null} → 404

无 token → 401 111102「请先登录」。

④ use_skill 的标签带 requires/missing(D38;read_skill 不带,正文逐字节相同):

真 run(deepseek-flash)里 tool_result.output 逐字:

正文:跑 python3。 # 同一技能用 read_skill 调: 正文:跑 python3。

⑤ 检查与 bash 用同一条 PATH(D39):/api/dev/workspace/bash 实跑(同一个 runBash)——

echo $PATH 里没有 /Users/…/.local/bin、/Users/…/.nvm/…、/Users/…/sdk/go/…;

在 ~/.local/bin 放一个可执行 tako-d1-fake 之后:

$ tako-d1-fake → 退出码 127,stderr: /bin/bash: tako-d1-fake: command not found

$ /Users/…/.local/bin/tako-d1-fake → 退出码 126,stderr: … Operation not permitted(+围栏提示)

$ python3 -V → Python 3.13.0(解析到 /Library/Frameworks/…/bin/python3,

与 check 的 path 同一份真实路径)

不装 sandbox-exec 的机器上 bash 本身 fail closed(requireSandbox),这条口径不成立;见 doc/26。

═══ 用例 29:技能作用域(doc/52 E1)—— 机器判红:expected.json 29-agent-skill-scope ═══

2026-10-28 隔离引擎 8943(tako_b2 库、workspace-c1),租户 t_01M6143HZN1NCT988GCYW5SAJF。

作用域收窄的是「主助手这一场的技能目录」,不是权限闸:管理员照旧能用 API 改技能表。

它在解析时点被使用(目录过滤 + read_skill/use_skill/read_skill_file/D35 看板恢复四处),

所以目录散文不是权威——名单抄进了提示词,模型越界去调也回同一个 116001。

① JSON 面收窄:JSON 字段叫 skillPolicy,与 md 的 skills:/exclude_skills: 同义(allow=只给这些,

exclude=从全集减去这些,inherit=不设作用域)。

curl -s -X POST -H "Authorization: Bearer $T" -H 'Content-Type: application/json'
-d '{"name":"scope-mgr","kind":"root","spec":"你是主助手。","skillPolicy":{"mode":"allow","names":["demo"]}}'
B/api/tenants/B/api/tenants/TID/agents → 201 {"code":0,"message":"","data":{"agent":{"id":"ag_…","defaultId":"","source":"custom","overridden":false,"name":"scope-mgr","description":"","spec":"你是主助手。","modelRef":"","toolPolicy":{"mode":"inherit","names":[]},"skillPolicy":{"mode":"allow","names":["demo"]},"visibility":"private"}}}

② 列表回读同一份(GET /api/tenants//agents?kind=root;列表里还有出厂行,此处只摘这一项),

skillPolicy 紧跟 toolPolicy:

{"name":"scope-mgr",…,"toolPolicy":{"mode":"inherit","names":[]},"skillPolicy":{"mode":"allow","names":["demo"]},"visibility":"private"}

③ 普通子代理写 inherit 放行——GET 回读总是带这一份,客户端原样 PUT 回来不该被拒:

POST /api/tenants//agents {"name":"scope-sub","kind":"subagent","spec":"你是子代理。", "skillPolicy":{"mode":"inherit","names":[]}} → 201,回读 {"skillPolicy":{"mode":"inherit","names":[]}}

④ 普通子代理写收窄(allow/exclude)→ 400;md 导入与 JSON 新建同判(同一个 skillScopeDeclared):

{"code":111002,"message":"skills:/exclude_skills: 只对主助手有效(普通子代理没有技能目录)","data":null}

⑤ 导入 md 里写 skills: [demo] 的普通子代理规格 → 同一字节 400(拒整个包,不落半份)。

出厂名 coder 是 kind=both(既能当主助手也能被委派),导入它的覆盖行写 exclude_skills: 放行:

{"code":0,"message":"","data":{"agents":[{"name":"coder",…,"skillPolicy":{"mode":"exclude","names":["demo"]},…}]}}

⑥ 缺省 = 全量目录(mode=inherit);skills: [] = 一个都不要(allow + 空名单,靠指针非 nil 区分)。

⑦ 运行期实录(2026-10-28,deepseek-flash;要模型 key,机器清单不断言):

allow ["dep-demo"] 起一场,问「只根据 <available_skills> 列出技能名」→ assistant 只回 dep-demo;

同一作用域下让它调 use_skill({"name":"dep-check"})(这个技能在表里、只是不在范围内):

{"code":116001,"message":"找不到这个技能,可能已被删除或改名","data":{"name":"dep-check"}}

——与查一个根本不存在的名字同字节(作用域外不泄漏存在性)。

改成 exclude ["dep-demo"] 后再调 use_skill({"name":"dep-demo"}) → 同一字节;

skills: [] 时目录一个条目都没有,模型答「无」。

═══ 用例 30:技能禁用(doc/52 E2)—— 机器判红:expected.json 30-skill-disable ═══

2026-10-28 隔离引擎 8943(tako_b2 库、workspace-c1),每轮由 signup 新建租户;

demo-off 由 seed_skill 造在 <WS_ROOT>/tenants//skills/demo-off/ 再 rescan 进表。

① 禁用 = 在 skill_disables 落一行(主键 (tenant_id,name),重复禁用无事):

curl -s -X PATCH -H "Authorization: Bearer $T" -H 'Content-Type: application/json'
-d '{"enabled":false}' $B/api/skills/demo-off → 200 {"code":0,"message":"","data":{"skill":{"name":"demo-off",…,"enabled":false,…}}}

② 列表与详情都读同一条禁用表(详情可看——管理面读的是表,不是「能不能用」):

GET /api/skills → data.skills 里 {"name":"demo-off",…,"enabled":false,…} GET /api/skills/demo-off → {"code":0,"message":"","data":{"skill":{…"enabled":false…},"body":"---\nname: demo-off…"}}

③ 恢复:{"enabled":true} → 200,回包 enabled:true;再禁用一次留给 ④。

④ 角色闸与登录闸是两道:viewer 打 PATCH → 403(真 viewer token,不是「没带 token」):

{"code":111203,"message":"没有权限做这件事","data":null}

不带 token → 401 {"code":111102,"message":"请先登录","data":null}

⑤ 删除同事务清禁用行:DELETE → {"status":"deleted"};同一名字重新 seed + rescan 后

列表回 enabled:true(若禁用行残留,这里会是 false——行为可证的级联)。

⑥ 禁用对 run 的生效面(要模型 key,机器清单不断言;2026-10-28 deepseek-flash 实录):

禁用 dep-demo 后问「只根据 <available_skills> 列出技能名」→ 回复里没有 dep-demo(其余在);

让它调 use_skill({"name":"dep-demo"}),tool_result 逐字:

{"code":116107,"message":"这个技能已被禁用,请先在管理页恢复","data":{"name":"dep-demo"}}

正在跑的 run 不回缩:盒子只在 use_skill 成功时登记,禁用不碰盒子——已开的执行权不中途收回

(与「进行中的 run 不受删除影响」同线,代码路径可证,无额外断言)。

⑦ 事件:禁用、恢复各推一条(curl -N $B/api/events 实录,seq/at 随写变,其余逐字):

data: {"seq":"","type":"skills_changed","id":"dep-demo","at":""}

不带 action——事件只通知、状态永远重拉(doc/46 §7.6;台账原写的 {action,name} 按 doc/46 收口)。

═══ 用例 31:工具上传写面(doc/52 D36 F1)—— 机器判红:expected.json 31-tools-write ═══

2026-10-28 隔离引擎 8943(tako_b2 库、workspace-c1),每轮由 signup 新建租户。

工具根 = <WS_ROOT>/tenants//tools/;不进表——列表就是 os.ReadDir,跳过 . 开头

(.staging 里在途上传的 bin/ 被列出来,就等于半成品抢先被使用)。

落盘五步:卡体积 → 占额度 → 落 .staging → 锁内「旧目录进 .trash + rename」→ 报。

① 上传(multipart 的 name 是用户给的字段,不是文件名;文件落 /bin/ 0755):

curl -s -X POST -H "Authorization: Bearer $T" -F name=hello -F file=@./hello $B/api/tools → 200 {"code":0,"message":"","data":{"tool":{"name":"hello","exe":true,"path":"/…/tmp/workspace-c1/tenants/t_01M6143HZN1NCT988GCYW5SAJF/tools/hello/bin/hello","bytes":38,"updatedAt":"2026-10-28T12:34:49Z"}}}

盘上(macOS 带 @ 是 xattr,权限位是 0755):

-rwxr-xr-x@ 1 yuweikang staff 38 Oct 28 20:34 hello

② 列表(所有成员可读;exe 是现算的「bin/ 存在且带执行位」,不进任何表):

{"code":0,"message":"","data":{"tools":[{"name":"hello","exe":true,"path":"…/tools/hello/bin/hello","bytes":38,"updatedAt":"2026-10-28T12:34:49Z"}]}}

③ 同名覆盖:staging 里换好再 rename,旧目录整棵进 .trash/-/:

{"code":0,"message":"","data":{"tool":{"name":"hello","exe":true,"path":"…","bytes":30,"updatedAt":"2026-10-28T12:34:51Z"}}} …/tools/.trash/hello-1793190891917988000

④ 坏输入一律 400 116117,盘上无新增(失败时 staging 由 defer 删掉,正式目录一个字节没动):

{"code":116117,"message":"工具名只能是小写字母、数字和连字符(64 字符以内)","data":null} # name=../evil、name=Bash {"code":116117,"message":""bash" 是保留名,不能用作工具名","data":null} # name=bash(sh/env 同) {"code":116117,"message":"工具名不能为空","data":null} {"code":116117,"message":"上传的文件是空的","data":null} {"code":116117,"message":"请用 multipart 上传 name 与 file","data":null}

>128MB → 413(MaxBytesReader 先卡请求体,再按 FileHeader.Size 复核):

{"code":116118,"message":"工具文件超过上限(134217728 字节)","data":null}

额度不足(先把本租户 max_storage_bytes 调小;ReserveStorage 先占后排):

{"code":113001,"message":"这个工作区的额度用完了","data":null} → 429

⑤ 角色闸与登录闸分开:viewer 上传 → 403(真 viewer token);GET /api/tools 仍 200;

不带 token → 401:

{"code":111203,"message":"没有权限做这件事","data":null} {"code":111102,"message":"请先登录","data":null}

⑥ 删除:前缀目录移进 .trash/-/;不存在(含 .. 这类不合规名字,先过同一套

白名单——filepath.Join(root, "..") 是租户根,移走它就是移走这个租户的全部东西):

{"code":116119,"message":"找不到这个工具","data":null} → 404 DELETE /api/tools/hello → {"code":0,"message":"","data":{"status":"deleted"}} GET /api/tools → {"code":0,"message":"","data":{"tools":[]}} ls tools/.trash/ → hello-1793190891917988000 hello-1793190909079870000

⑦ 事件与技能那条同形(doc/46 §7.6),type 单独叫 tools_changed——客户端按 type 决定重拉哪一页:

curl -sN -H "Authorization: Bearer $T" $B/api/events(另一窗口上传时实录)

data: {"seq":"1793190912472-0","type":"tools_changed","id":"hello","at":"2026-10-28T12:35:12Z"}

⑧ 装上就能用由 F2 的活体回答(PATH 前置 + 围栏只读),本拍只保证「文件到了约定的位置」。

⑨ 24h 清扫(doc/52 §4.6 第 4 条、G1 已验 2026-10-28):下一次写操作在锁内按 mtime 清

.staging / .trash,启动时不扫盘、失败只记日志。实跑:把 .trash/g1-old-tool-1 与

.staging/g1-old-tstage 的 mtime 置成 25 小时前,另放一个刚建的 → 调

DELETE /api/tools/g1-no-such-tool(404 116119,锁内先清扫)之后旧的两条消失、刚建的留下:

ls tools/.trash/ → hello-1793190891917988000 …(当天那批);ls tools/.staging/ → 空

技能根同一时刻由一次租户 POST /api/skills/rescan 清(skills/.trash/g1-old-1 与

skills/.staging/g1-old-stage 消失,skills/.trash/g1-fresh-1 留下)。

豁免(审计补拍 2026-10-28):批准一枪不清自己的源。造两个 48 小时前的 staging

(audit-keep-0001 被一条 pending 的 kind=install 行指向、audit-junk-0002 没人认领)→

POST /api/questions/q_audit_g1_keep/answer {"decision":"approve"} 回

200 {"code":0,"message":"","data":{"answer":"已安装技能:g1-aged。","questionId":"q_audit_g1_keep","status":"answered"}};

盘上 skills/g1-aged/SKILL.md 就位、skill_rows 有行、skills/.staging 清空

(没人认领的那份被同一枪清掉 = 清扫真跑了,豁免只保住正在 rename 的那份)。

═══ 用例 32:读分页(doc/58 §3)—— 机器判红:expected.json 32-read-pagination ═══

2026-11-01 隔离引擎 8943(tako_acc 库、workspace-acc),每轮由 signup 新建租户 →

dev 会话工作区是新的 → 文件不与上一轮串味。

读工具的字节只有 dev 口打得到(POST /api/dev/workspace/read = 直接调 read_file

工具、回它的输出原文):read 的输出是模型侧字节,四个产品端点打不到它。

dev 口只在 -dev 模式注册(与 workspace/file、workspace/bash 同族)。

① 造文件(dev 口写的是 dev 会话工作区):

curl -s -X POST -H "Authorization: Bearer $T" -H 'Content-Type: application/json'
-d '{"path":"d58-page.txt","content":"line 1\nline 2\nline 3\n"}' $B/api/dev/workspace/file → 201 {"code":0,"message":"","data":{"path":"d58-page.txt","sessionId":"s_01M6AG7PF03YCM2P1B2TZ5VD3X"}}

② 全文读完:页脚只报总行数(head/tail 已删,总行数是模型唯一的定位坐标):

curl -s -X POST -H "Authorization: Bearer $T" -H 'Content-Type: application/json'
-d '{"path":"d58-page.txt"}' $B/api/dev/workspace/read → 200 {"code":0,"message":"","data":{"output":"line 1\nline 2\nline 3\n\n(已读到文件末尾,共 3 行)","sessionId":"s_01M6AG7PF03YCM2P1B2TZ5VD3X"}}

③ 切片:offset 1-based、limit 是行数;页脚给下一个 offset:

-d '{"path":"d58-page.txt","offset":2,"limit":1}' → 200 {"code":0,"message":"","data":{"output":"line 2\n\n(已显示第 2-2 行,共 3 行;继续读用 offset=3)","sessionId":"s_…"}}

④ 三条错路径(400 111002,文案带当时给的数):

-d '{"path":"d58-page.txt","offset":9}' → {"code":111002,"message":"offset 9 超出文件末尾(共 3 行)","data":null} -d '{"path":"d58-page.txt","offset":0}' → {"code":111002,"message":"offset 须为正整数(给的是 0)","data":null} -d '{"path":"d58-page.txt","limit":5000}' → {"code":111002,"message":"limit 不得大于 2000(给的是 5000)","data":null} -d '{"path":"d58-nope.txt"}' → {"code":111002,"message":"文件不存在:d58-nope.txt","data":null}

⑤ 200KB 那条硬报错已撤(doc/58 §3.2):>200KB 的文件照样流式分页读。

每页 2000 行 / 50KB / 单行 2000 字符这三档上限由 go test 的 TestReadTextFileBasic、

TestReadTextFileLargeFilePaged、TestReadTextFileByteCapFooter 逐字钉住

(快闸在 yk-tako-eino/internal/runengine/filetools_test.go)。

═══ 用例 33:bash 输出留存(doc/58 §4)—— 机器判红:expected.json 33-bash-output-retention ═══

2026-11-01 隔离引擎 8943。bash 需要围栏后端:macOS 是 sandbox-exec,Linux 是 bwrap

#(2026-11-03 补齐,doc/problems/没有沙箱的系统怎么办);两套后端探测失败都 fail closed。

清单里这条标了 needs=sandbox → 没有后端时跳过并说明原因,不假装跑过。

dev 口每请求一个新 run id → 落盘路径逐请求变 → 清单用 data_contains 断「含哪几段」,

不逐字比全文。

① 小输出(≤64000 字节/流):形状与今天逐字相同(退出码 + stdout,末尾换行照旧):

curl -s -X POST -H "Authorization: Bearer $T" -H 'Content-Type: application/json'
-d '{"cmd":"echo hi"}' $B/api/dev/workspace/bash → 200 {"code":0,"message":"","data":{"output":"退出码:0\nstdout:\nhi\n","sessionId":"s_…","sandboxed":true}}

② 大输出(100000 字节):内存只留尾部 64000 字节,全文落盘、末尾加一行回路径。

尾部正好 64000 字节这件事由 go test 的 TestBashKeepsTailAndSpillsWhole 逐字钉住;

这一行里的尾窗是 64000 个 x:

data.output = "退出码:0\nstdout:\n" + "x"×64000 + "\n(stdout 完整输出已存到 .tako/bash/r_01M6AG9XVA4KT40TKQXSVCAPC6/1.out,共 100000 字节;用 read_file 分页读它)"

③ 落盘的文件真在盘上(不是「路径写进结果就算数」):下一条 bash 用纯内建把它读回来量长度。

$(< file) 与 ${#v} 都是 bash 内建 —— 不依赖外部程序,围栏里也跑得动:

-d '{"cmd":"for f in .tako/bash/*/1.out; do v=$(< \"$f"); echo "${#v}"; done"}' → 200 {"code":0,"message":"","data":{"output":"退出码:0\nstdout:\n100000\n","sessionId":"s_…","sandboxed":true}}

④ 小输出那次没建落盘目录(落盘目录只在首次溢出时建):数一遍目录个数 = 1(大输出那一个):

-d '{"cmd":"n=0; for d in .tako/bash/*/; do [ -d "$d\" ] && n=$((n+1)); done; echo $n"}' → 200 {"code":0,"message":"","data":{"output":"退出码:0\nstdout:\n1\n","sessionId":"s_…","sandboxed":true}}

⑤ 30 天清扫(doc/58 §4.4):每次 bash 调用前扫一次 .tako/bash/,超期目录整棵删。

这条要改 mtime 造场景,由 go test 的 TestSweepBashSpills 钉住(活体不铺这条)。

═══ 用例 34:提问分段与问答读口(doc/47 §5.5,2026-11-03)—— 机器判红:见下 ═══

要模型真的调 ask_user 才造得出,登记 declared_not_asserted(同用例 11 先例);

响应形状由快闸逐字钉住:TestContractLogQuestionSegmentsBytes(segments 的键序与省略)

与 TestContractQuestionViewBytes(toolCallId/answer 的键序)。以下是 2026-11-03 隔离引擎

8943 的真实字节(ask 前有正文那场)。

① 发一轮「先用一句话说『我先确认一下』,然后调 ask_user 问我选 A 还是 B,答完只回复 ok」:

curl -s -X POST -H "Authorization: Bearer $T" -H 'Content-Type: application/json'
-d '{"messageId":"m_segB","text":"先用一句话说『我先确认一下』,然后调用 ask_user 问我选 A 还是 B,拿到回答后只回复 ok"}'
$B/api/runs → 202 {"code":0,"message":"","data":{"sessionId":"s_01…","runId":"r_01…","messageId":"m_segB"}}

② 待答行带 toolCallId(answer 字段仍不出现,omitempty):

curl -s -H "Authorization: Bearer $T" "$B/api/runs/$RID/questions?status=pending" → 200 {"code":0,"message":"","data":[ {"questionId":"qs_01…","runId":"r_01…","toolCallId":"call_00_…","kind":"question", "question":"你选 A 还是 B?","args":"{"question":"你选 A 还是 B?","options":["A","B"]}", "status":"pending","createdAt":"2026-11-03T20:38:…"}]}

③ 答题:

curl -s -X POST -H "Authorization: Bearer $T" -H 'Content-Type: application/json'
-d '{"answer":"A"}' B/api/questions/B/api/questions/QID/answer → 200 {"code":0,"message":"","data":{"questionId":"qs_01…","status":"answered"}}

④ 定稿后的 log:仍是一条 assistant 行(Σ 正文),payload 里的 segments 按 rune 偏移切段。

正文「我先确认一下。ok」共 8 个 rune,end=7 切出「我先确认一下。」/「ok」:

curl -s -H "Authorization: Bearer $T" "$B/api/sessions/$SID/log?runlogOffset=0" → 200 {"code":0,"message":"","data":{"rows":[ {"runlogOffset":1,"runId":"r_01…","role":"user","agent":"","model":"","messageId":"m_segB", "text":"先用一句话说『我先确认一下』,然后调用 ask_user 问我选 A 还是 B,拿到回答后只回复 ok"}, {"runlogOffset":2,"runId":"r_01…","role":"tool_call","agent":"","model":"deepseek/deepseek-flash", "text":"ask_user({"question": "你选 A 还是 B?", "options": ["A", "B"]})","payload":"{"name":"ask_user",…}"}, {"runlogOffset":3,"runId":"r_01…","role":"tool_result","agent":"","model":"deepseek/deepseek-flash", "text":"A","payload":"{"name":"ask_user","output":"A","toolCallId":"call_00_…"}"}, {"runlogOffset":4,"runId":"r_01…","role":"assistant","agent":"","model":"deepseek/deepseek-flash", "text":"我先确认一下。ok", "usage":{"promptTokens":6660,"completionTokens":2,"totalTokens":6662,"window":256000}, "segments":[{"end":7,"toolCallId":"call_00_…"}]} ],"nextOffset":4}}

⑤ 已答行带 answer 与 toolCallId(三类 kind 都返回 answer;plan 行是编辑后方案/驳回意见):

curl -s -H "Authorization: Bearer $T" "$B/api/runs/$RID/questions?status=answered" → 200 {"code":0,"message":"","data":[ {"questionId":"qs_01…","runId":"r_01…","toolCallId":"call_00_…","kind":"question", "question":"你选 A 还是 B?","args":"…","status":"answered","answer":"A","createdAt":"2026-11-03T20:38:…"}]}

⑥ 没有提问的 run(「只回复 ok」):两条行,assistant 行不出现 segments,payload 与今天一致:

GET /api/sessions/$SID/log?runlogOffset=0 → rows = user + assistant,assistant 无 "segments" 键。

═══ 用例 35:markdown 模式观测口守卫(doc/65 §6.5)—— 机器判红:expected.json 35-memory-mode-guard(needs=markdown-mode)═══

2026-11-10 markdown 模式隔离引擎(TAKO_MEMORY_MODE=markdown)实跑抄下来的字节。

守卫的意义:markdown 模式的记忆在两份纯文本文件里,观测口看不见它们——回空数组会被读成

「这个租户一条记忆都没有」,所以统一 409/118001,把「看不见」与「没有」分开。

TOK=$(curl -s $B/api/auth/signup -H 'Content-Type: application/json'
-d '{"email":"md@acc.test","password":"acc-pass-1234","displayName":"MD"}' | jq -r .data.accessToken)

curl -s "$B/api/memory/items?limit=1" -H "Authorization: Bearer $TOK" → 409 {"code":118001,"message":"当前记忆模式不提供这个观测口","data":null}

curl -s "$B/api/memory/jobs" -H "Authorization: Bearer $TOK" → 409 {"code":118001,"message":"当前记忆模式不提供这个观测口","data":null}

curl -s "$B/api/memory/recall?q=test" -H "Authorization: Bearer $TOK" → 409 {"code":118001,"message":"当前记忆模式不提供这个观测口","data":null}

跑套件时引擎与运行器要同带 TAKO_MEMORY_MODE=markdown,否则这条跳过(assert_contract.py 的 needs 门)。

dialogue 观测口两种模式都保留,不过这道守卫(不在本用例)。

═══ 用例 36:pipeline 观测口 items(doc/65 §6.5)—— 机器判红:expected.json 36-memory-items-observe(needs=pipeline-mode)═══

2026-11-10 pipeline 隔离引擎(tako_e)实跑抄下来的字节。空租户 = 刚注册、没有任何记忆任务。

TOK=$(curl -s $B/api/auth/signup -H 'Content-Type: application/json'
-d '{"email":"pipe@acc.test","password":"acc-pass-1234","displayName":"Pipe"}' | jq -r .data.accessToken)

curl -s "$B/api/memory/items?limit=1" -H "Authorization: Bearer $TOK" → 200 {"code":0,"message":"","data":{"items":[]}}

state 枚举校验(非法值在进存储层之前拒):

curl -s "$B/api/memory/items?state=bogus" -H "Authorization: Bearer $TOK" → 400 {"code":111002,"message":"state 只能是 active、superseded、removed 或 archived","data":null}

═══ 用例 37:pipeline 观测口 jobs(doc/65 §4.5)—— 机器判红:expected.json 37-memory-jobs-observe(needs=pipeline-mode)═══

响应字段集是 doc/65 的新 memory_jobs(id/runId/kind/targetLayer/status/attempts/claimEpoch/

leaseUntil/nextAttemptAt/lastError/createdAt/updatedAt;批次字段在服务端日志不在行里)。

空租户的形状:

curl -s "$B/api/memory/jobs" -H "Authorization: Bearer $TOK" → 200 {"code":0,"message":"","data":{"jobs":[]}}

═══ 用例 38:pipeline 召回口(doc/40 A7-5 信封)—— 机器判红:expected.json 38-memory-recall-shape(needs=pipeline-mode)═══

data 的键序是 gin.H 的字母序:block → dialogueHits → injectedRunes → memoryHits。

无命中(生造词,BM25 打不中任何行):

curl -s "$B/api/memory/recall?q=%E7%BB%9D%E5%AF%B9%E6%B2%A1%E6%9C%89%E7%9A%84%E8%AF%8DXYZQ" -H "Authorization: Bearer $TOK" → 200 {"code":0,"message":"","data":{"block":"","dialogueHits":0,"injectedRunes":0,"memoryHits":0}}

缺 q(空串按缺参处理):

curl -s "$B/api/memory/recall?q=" -H "Authorization: Bearer $TOK" → 400 {"code":111001,"message":"请求格式不对","data":null}

═══ 用例 39:记忆工具回执与抽取落行的端到端(doc/65 §13.3-1)—— 声明但暂不断言(模型行为)═══

「模型会不会真调 memory 工具、targetLayer 给什么」随模型飘,core tier 没有造行的 HTTP 入口。

工具「已受理」回执、inrun/postrun 双抽取不重复落、supersede/remove 指针与 left_active_at、

BM25 召回命中与旧说法退场:活体判红在 scripts/acceptance/memory_pipeline_live.sh(20 断言,

真 broker + 真模型);markdown 侧由 memory_markdown_live.sh 判红。

抽取行的来源指针(SourceRunID/SourceSeq 由程序从 job 补)由 go test 的

memory_write_test.go TestMemoryWriteInsertHappyPath 钉住。

═══ 用例 40:消费者崩溃补投恰好一次(doc/65 §13.3-2)—— 声明但暂不断言(要 kill -9 引擎)═══

kill -9 正在处理记忆任务的引擎 → 重启 → broker 重投/对账器租约过期补投,最终行只落一条、

A→B→A 不被内容去重吞掉。活体判红在 scripts/acceptance/memory_redpanda_crash.sh

(TAKO_ENGINE_PIDS/TAKO_ENGINE_RESTART 参数化)。

═══ 用例 41:文件锁竞争与原子替换(doc/65 §13.3-4)—— 声明但暂不断言(要双引擎竞争)═══

两个隔离引擎共连同一 PG/共享 workspace:flock 跨进程串行、写前版本拒绝(文件字节 ≠ 读到的版本)、

原子替换期间读者只见完整新旧版、kill -9 释放锁。活体判红在 scripts/acceptance/memory_file_race.sh;

存储侧不变量由 go test 钉住。

═══ 用例 42:旧 notes/memory_items 升级迁移与模式互切(doc/65 §13.3-5)—— 声明但暂不断言(要旧形态库)═══

预置旧 notes/kind/topic 数据的库跑 -memory-migrate-to=markdown|pipeline:行数不丢、

迁移产物归档(archived + left_active_at)、重放不重复、域冲突整批拒。活体判红在

scripts/acceptance/memory_migrate_live.sh(42 断言)。

═══ 用例 43:项目删除的连带清理(doc/65 §13.3-6)—— 声明但暂不断言(要真删项目)═══

删 workspace 项目:workspace 两类行都清、user 行跨项目仍可见、markdown 模式 USER.md 不变、

runs/runlog 不变。活体判红在 scripts/acceptance/memory_project_delete_live.sh;

删除级联的存储侧由 go test 的 delete_cascade_test.go 钉住。

═══ 用例 44:单件 Task 创建 / 读回 / 幂等(doc/70 §4)—— 机器判红:expected.json 44-tasks-create-read-idempotent(needs=pg)═══

起法:隔离引擎带 -task-interval=-1s(调度关)。下面 $SID 是 SQL 造的来源会话

(普通 chat 会话挂项目,INSERT … RETURNING id),$WID 是 POST /api/workspaces 建的项目。

curl -s $B/api/workspaces -H "Authorization: Bearer $T" -d '{"name":"acc-task-home"}' → 201 {"code":0,"message":"","data":{"workspace":{…}}}

curl -s $B/api/tasks -H "Authorization: Bearer $T"
-d '{"idempotencyKey":"acc44","workspaceId":"'$WID'","sourceSessionId":"'$SID'", "content":"阅读项目根目录并总结有哪些文件","agent":"researcher"}' → 202 {"code":0,"message":"","data":{"taskId":"at_01…","orchestrationId":"or_01…","status":"ready","currentRunId":""}}

data 键序固定四键:taskId → orchestrationId → status → currentRunId。单件 Task = 单节点编排组。

require_status 探针:GET 三秒轮询,ready 不被领走(调度没关的红在这里)

curl -s "B/api/tasks/B/api/tasks/TID" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{ "taskId":"at_01…","orchestrationId":"or_01…","key":"main","content":"阅读项目根目录并总结有哪些文件", "agent":"researcher","modelRef":"","planCheckpoint":false,"createdRevision":0, "workspaceId":"ws_01…","status":"ready","currentRunId":"", "result":null,"error":null,"resultRevision":0, "createdAt":"2026-11-10T…","startedAt":null,"finishedAt":null,"updatedAt":"2026-11-10T…"}}

18 键序:taskId → orchestrationId → key → content → agent → modelRef → planCheckpoint → createdRevision

→ workspaceId → status → currentRunId → result → error → resultRevision → createdAt → startedAt → finishedAt → updatedAt

创建时带 "planCheckpoint":true(单件 Task 直接在 POST /api/tasks 顶层传,doc/72 §4.7),读回即 true;

该件成功后组进 plan_hold 并插一条 plan_review_required 通知——这一段要调度在跑才发生,

由 scheduler 单测与 doc/72 的活体脚本判红,本用例只钉「字段能创建、能读回」。

curl -s "B/api/workspaces/B/api/workspaces/WID/tasks" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"tasks":[ … 上面同形的 Task 视图 … ]}}

同键同计划再发一次 = 幂等命中原组,不建第二份:

curl -s $B/api/tasks -H "Authorization: Bearer $T" -d '…同上…' → 202 {"code":0,"message":"","data":{"taskId":"at_01…(同 id)","orchestrationId":"or_01…","status":"ready","currentRunId":""}}

═══ 用例 45:同键不同计划 = 409 117102(doc/70 §6)—— 机器判红:expected.json 45-tasks-idempotency-conflict(needs=pg)═══

创建幂等的本体是 (tenant_id, source_session_id, idempotency_key) 唯一索引:

同键命中后回读比对 plan_hash——同 = 原组,异 = 117102,不给静默覆盖。

curl -s $B/api/tasks … -d '{"idempotencyKey":"acc45", …"content":"换了一份内容的计划"}' → 409 {"code":117102,"message":"这个创建键已经用于另一份计划","data":null} curl -s $B/api/tasks … -d '{"idempotencyKey":"acc45", …,"agent":"coder"}' # 只换执行者也一样 → 409 {"code":117102,"message":"这个创建键已经用于另一份计划","data":null}

═══ 用例 46:创建校验负路径(doc/70 §4.4)—— 机器判红:expected.json 46-tasks-create-validation(needs=pg)═══

curl -s $B/api/tasks -d '{}' → 400 {"code":111002,"message":"idempotencyKey、workspaceId、sourceSessionId、content、agent 都是必填","data":null} curl -s $B/api/tasks -d '{…"agent":"ghost"}' → 404 {"code":112003,"message":"找不到执行者规格","data":null} curl -s $B/api/tasks -d '{…"workspaceId":"ws_nope"}' → 404 {"code":114001,"message":"找不到这个项目","data":null} curl -s $B/api/tasks -d '{…"sourceSessionId":"s_nope"}' → 404 {"code":112001,"message":"找不到这场会话","data":null}

来源会话已删(SQL UPDATE sessions SET deleted_at=now())与不存在同形:

curl -s $B/api/tasks … → 404 {"code":112001,"message":"找不到这场会话","data":null}

无模型租户 + 显式 modelRef → 409 111408(ref 只是发给 API 的字符串,引擎级不校验模型名;

校验面 = 租户没有可解的模型配置):

curl -s $B/api/tasks -d '{…"modelRef":"deepseek/deepseek-flash"}' → 409 {"code":111408,"message":"这个工作区的模型还不可用","data":null}

═══ 用例 47:编排计划形状校验(doc/70 §6)—— 机器判红:expected.json 47-orchestration-plan-validation(needs=pg)═══

形状规则全部在创建服务(400 117101,原因进 data.reason):

curl -s $B/api/orchestrations -d '{…"goal":"成环图","tasks":[a,b],"links":[a→b,b→a]}' → 400 {"code":117101,"message":"任务计划不合法","data":{"reason":"依赖边成环,无法拓扑排序"}} curl -s $B/api/orchestrations -d '{…"tasks":[a,b],"links":[]}' → 400 {"code":117101,"message":"任务计划不合法","data":{"reason":"一张编排图必须恰好有一个无子节点的最终 Task,现在有 2 个"}} curl -s $B/api/orchestrations -d '{…"tasks":[],"links":[]}' → 400 {"code":117101,"message":"任务计划不合法","data":{"reason":"一件编排组需要 1–32 件 Task"}} curl -s $B/api/orchestrations -d '{…"tasks":[a],"links":[a→a]}' → 400 {"code":117101,"message":"任务计划不合法","data":{"reason":"依赖边不允许自依赖:a"}} curl -s $B/api/orchestrations -d '{…"tasks":[{"key":"-bad",…}]}' → 400 {"code":117101,"message":"任务计划不合法","data":{"reason":"Task key 只允许字母数字开头的 1–64 位字母数字、_ 或 -:-bad"}}

数字开头合法(^[A-Za-z0-9]…);必填缺失仍归 handler 的 111002。

═══ 用例 48:两节点编排创建 / 读回(doc/70 §4.2)—— 机器判红:expected.json 48-orchestration-create-read(needs=pg)═══

curl -s $B/api/orchestrations -H "Authorization: Bearer $T"
-d '{"idempotencyKey":"acc48","workspaceId":"'$WID'","sourceSessionId":"'$SID'", "goal":"两步调研后汇总", "tasks":[{"key":"a","content":"调研主题 A","agent":"researcher"}, {"key":"b","content":"汇总调研结论","agent":"coder"}], "links":[{"parent":"a","child":"b"}]}' → 202 {"code":0,"message":"","data":{"orchestrationId":"or_01…","status":"active"}}

curl -s "B/api/orchestrations/B/api/orchestrations/OID" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{ "orchestration":{"orchestrationId":"or_01…","goal":"两步调研后汇总","workspaceId":"ws_01…", "sourceSessionId":"s_01…","status":"active","finalTaskId":"at_01…(b 的 id)", "planRevision":0,"planHold":false, "deliveryStatus":"","deliveryRunId":"","createdAt":"…","finishedAt":null,"deliveredAt":null,"updatedAt":"…"}, "tasks":[ …key a:status ready(根)…, …key b:status pending(有依赖,父成功后才升)… ], "links":[{"parentTaskId":"at_01…(a)","childTaskId":"at_01…(b)"}]}}

data 三段键序 orchestration → tasks → links;组半 14 键序(doc/70 §4 + doc/72 §4.7 的两列):

orchestrationId → goal → workspaceId → sourceSessionId → status → finalTaskId → planRevision → planHold

→ deliveryStatus → deliveryRunId → createdAt → finishedAt → deliveredAt → updatedAt

tasks 按 created_at + task_key 稳定序;finalTaskId = 出度为 0 的汇(不是根)。

同键同计划幂等:→ 202 {"code":0,"message":"","data":{"orchestrationId":"or_01…(同 id)","status":"active"}}

═══ 用例 49:可见性与角色(doc/70 §4.5)—— 机器判红:expected.json 49-tasks-notfound-permission(needs=pg)═══

可见性 = 来源会话的主人(store 层 JOIN sessions.user_id)。同租户非主人与不存在同形 404,不给探测通道。

curl -s "$B/api/tasks/at_nope" -H "Authorization: Bearer $T" → 404 {"code":117001,"message":"找不到这件任务","data":null} curl -s "$B/api/orchestrations/or_nope" … → 404 {"code":117002,"message":"找不到这个编排组","data":null} curl -s "$B/api/tasks/at_nope/stop" -X POST … → 404 117001(stop/resume 同码) curl -s "$B/api/tasks/at_nope/resume" -X POST … → 404 117001 curl -s "$B/api/orchestrations/or_nope/stop" -X POST … → 404 117002

不带 token:

curl -s "B/api/tasks/B/api/tasks/TID" → 401 {"code":111102,"message":"请先登录","data":null} curl -s "$B/api/tasks" -X POST … → 401 {"code":111102,"message":"请先登录","data":null}

同租户 viewer(invited):读 → 404 117001 同形;列表 → 404 114001;写 → 403 111203:

curl -s "B/api/tasks/B/api/tasks/TID" -H "Authorization: Bearer $VIEWER_T" → 404 {"code":117001,"message":"找不到这件任务","data":null} curl -s "$B/api/workspaces/$WID/tasks" -H "Authorization: Bearer $VIEWER_T" → 404 {"code":114001,"message":"找不到这个项目","data":null} curl -s "$B/api/tasks" -X POST -H "Authorization: Bearer $VIEWER_T" -d '…' → 403 {"code":111203,"message":"没有权限做这件事","data":null}

跨租户 stranger:GET → 404 117001 同形。

═══ 用例 50:停止与恢复的状态面(doc/70 §8.4 / §10.1)—— 机器判红:expected.json 50-tasks-stop-resume(needs=pg)═══

先建一件单件 Task(key acc50t)与一个两节点编排组(key acc50o)。

单件 Task 与编排组共用同一幂等键空间(唯一索引在 (tenant, source_session, idempotency_key)):

同一来源会话里同键先建单件再建组 → 409 117102,这层共用本身是要钉的契约。

curl -s "B/api/tasks/B/api/tasks/TID/stop" -X POST -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"status":"cancelled","taskId":"at_01…"}} # gin.H 字母序 status → taskId

重复 stop 对 cancelled 幂等(不是 117104):

curl -s "B/api/tasks/B/api/tasks/TID/stop" -X POST … → 200 {"code":0,"message":"","data":{"status":"cancelled","taskId":"at_01…"}}

SQL 强置 status='succeeded' 再停 → 117104(终态分支只认 succeeded/failed):

curl -s "B/api/tasks/B/api/tasks/TID/stop" -X POST … → 409 {"code":117104,"message":"这件任务已经结束,不能停止","data":null}

cancelled 且从未领取(currentRunId 空)→ resume 117103「还没有执行记录」:

curl -s "B/api/tasks/B/api/tasks/TID/resume" -X POST … → 409 {"code":117103,"message":"这件任务还没有执行记录,不能恢复","data":null}

整组 stop(组内无 running 节点:pending/ready 当场翻 cancelled,组当场 cancelled):

curl -s "B/api/orchestrations/B/api/orchestrations/OID/stop" -X POST -H "Authorization: Bearer $T" → 202 {"code":0,"message":"","data":{"orchestrationId":"or_01…","status":"cancelled"}} curl -s "$B/api/orchestrations/$OID/stop" -X POST … → 409 {"code":117105,"message":"这个编排组已经结束,不能停止","data":null} curl -s "$B/api/orchestrations/$OID" -H "Authorization: Bearer $T" → 200 …"orchestration":{"status":"cancelled","finishedAt":"…"}, "tasks":[{a: cancelled},{b: cancelled}]

═══ 用例 51:计划修订的命令、幂等与版本(doc/72 §4.3)—— 机器判红:expected.json 51-plan-revision-contract(needs=pg)═══

组先按用例 48 的形状建 a→b。修订只允许在组 active 且最终 Task 未开始时追加未来任务。

先校验命令形状(400 117101,原因进 data.reason),再校验 baseRevision 是否等于当前计划版本:

curl -s "B/api/orchestrations/B/api/orchestrations/OID/revisions" -H "Authorization: Bearer $T"
-d '{"idempotencyKey":"acc51r0","baseRevision":0,"reason":"空命令", "addTasks":[],"addLinks":[],"cancelTasks":[],"finalTaskKey":""}' → 400 {"code":117101,"message":"任务计划不合法","data":{"reason":"修订命令为空"}} curl -s … -d '{…"baseRevision":99,…}' → 400 {"code":117101,"message":"任务计划不合法","data":{"reason":"baseRevision 不合法"}}

拿一条比当前更晚的 baseRevision 提交(先成功过一次再重放旧版本):

→ 409 {"code":117106,"message":"计划已有新修订,请重新读取后再试","data":null}

成功 = 201,data 六键序:

curl -s … -d '{"idempotencyKey":"acc51r3","baseRevision":0,"reason":"A 的结果表明必须补充 D", "addTasks":[{"key":"d","content":"补充调研 D,写入 d.md","agent":"researcher","modelRef":"","planCheckpoint":false}], "addLinks":[{"parent":"d","child":"b"}],"cancelTasks":[],"finalTaskKey":""}' → 201 {"code":0,"message":"","data":{"revisionId":"pr_01…","orchestrationId":"or_01…","revision":1, "finalTaskId":"at_01…","planHold":false,"addedTaskIds":["at_01…"]}}

键序:revisionId → orchestrationId → revision → finalTaskId → planHold → addedTaskIds。

finalTaskId 是修订后的汇(没换终态任务时不变);addedTaskIds 按命令顺序,没有新任务时是 []

(不是 null——空数组也要有)。

同键同命令重放 = 幂等命中同一次修订,回同一条 revisionId(不新建、不改计划):

→ 201 {"code":0,"message":"","data":{"revisionId":"pr_01…(同 id)","revision":1,…}}

同键换一份仍然合法的命令 = 409 117108(键已绑定另一份修订命令,拒绝静默覆盖):

→ 409 {"code":117108,"message":"这个修订键已经用于另一次修订","data":null}

修订历史按 revision 升序,行内保存原命令(addTasks 行带 modelRef 与 planCheckpoint):

curl -s "B/api/orchestrations/B/api/orchestrations/OID/revisions" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"revisions":[{"revisionId":"pr_01…","revision":1,"baseRevision":0, "reason":"A 的结果表明必须补充 D", "addTasks":[{"key":"d","content":"补充调研 D,写入 d.md","agent":"researcher","modelRef":"","planCheckpoint":false}], "addLinks":[{"parent":"d","child":"b"}],"cancelTasks":[],"finalTaskKey":"","sourceRunId":"", "createdAt":"2026-11-11T…"}]}}

data 一键 revisions;行内 addLinks 用的是命令形状(parent/child 是 key),不是任务 id——

id 映射只在 201 的 addedTaskIds 与读组时的 links 上出现。

未知组 → 404 117002;组已停(先 stop)→ 409 117107「这个编排组现在不能修订」。

═══ 用例 52:解除计划暂停(continue)(doc/72 §4.4)—— 机器判红:expected.json 52-plan-continue-contract(needs=pg)═══

continue 只做一件事:在「版本仍是提交时的版本、组 active、plan_hold=true」时把 plan_hold 清掉。

与修订的边界不同:不要求最终 Task 未开始——检查点常常就是把最终 Task 本身跑完的那一件,

加上这条会让单件组永远解除不了暂停(修订才保留该约束)。组没进暂停时回 200 且不动任何行。

curl -s "B/api/orchestrations/B/api/orchestrations/OID/continue" -H "Authorization: Bearer $T" -d '{"baseRevision":0}' → 200 {"code":0,"message":"","data":{"orchestrationId":"or_01…","revision":0,"planHold":false}}

data 三键序:orchestrationId → revision → planHold。

curl -s … -d '{"baseRevision":1}' → 409 {"code":117106,"message":"计划已有新修订,请重新读取后再试","data":null}

SQL 把组置 plan_hold=true 后再 continue:解除并回 planHold=false;

再发一次同命令仍 200(此刻 plan_hold 已 false,是空操作,不产生新事件):

→ 200 {"code":0,"message":"","data":{"orchestrationId":"or_01…","revision":0,"planHold":false}}

未知组 → 404 117002;组已停 → 409 117107(与修订共用这一条拒绝)。

═══ 用例 53:Task 的问题列表与回答(doc/72 §5)—— 机器判红:expected.json 53-task-questions-contract(needs=pg)═══

Task 执行器重新拿到 ask_user;它写进 run_questions 的行同时带 run_id/session_id 与 expires_at。

读面按 Task 当前 run 归属过滤,按 created_at, id 升序(同刻按 id 才是稳定序):

curl -s "B/api/tasks/B/api/tasks/TID/questions" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":[{"questionId":"qs_…","runId":"r_…","toolCallId":"call_…", "kind":"question","question":"要红还是蓝?","args":"{"question":"要红还是蓝?"}", "status":"pending","createdAt":"2026-11-11T…","expiresAt":"2026-11-12T…"}]}

行键序:questionId → runId → toolCallId → kind → question → args → status → createdAt → expiresAt;

expiresAt 只在建行时设了截止时间才出现(旧行没有这一键,不是空字符串)。

curl -s "B/api/tasks/B/api/tasks/TID/questions?status=answered" → 200 {"code":0,"message":"","data":[]} curl -s "B/api/tasks/B/api/tasks/TID/questions?status=bogus" → 400 {"code":111002,"message":"status 只能是 pending / answered / stale","data":null} curl -s "$B/api/tasks/at_nope/questions" → 404 {"code":117001,"message":"找不到这件任务","data":null}

回答复用既有端点(doc/47 的 POST /api/questions/:id/answer),Task 作用域不新增写口:

curl -s "B/api/questions/B/api/questions/QID/answer" -H "Authorization: Bearer $T" -d '{"answer":"红"}' → 200 {"code":0,"message":"","data":{"questionId":"qs_…","status":"answered"}} curl -s "$B/api/tasks/$TID/questions?status=answered" → 200 …[{"questionId":"qs_…","status":"answered","answer":"红"}] curl -s …/answer -d '{"answer":"再答一次"}' → 409 {"code":115101,"message":"这个问题已经答过了","data":null}

已过 expires_at 的 pending 行再答 → 409 115102「这个问题已经过期」;后台 job 会把过期行翻 stale。

═══ 用例 54:左栏「任务」关注聚合(doc/72 §6)—— 机器判红:expected.json 54-task-attention-contract(needs=pg)═══

聚合是读时算的,不建未读表:一个 GET 把四类需要人介入的事拼成 items。

curl -s "B/api/workspaces/B/api/workspaces/WID/task-attention" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"items":[{"kind":"question","taskId":"at_…","orchestrationId":"or_…", "title":"问一句","count":1,"questionId":"qs_…","runId":"r_…","status":"running", "updatedAt":"2026-11-11T…"}]}}

data 一键 items;item 九键序:kind → taskId → orchestrationId → title → count → questionId → runId

→ status → updatedAt。四类的取数条件:

question Task 与当前 run 都 running、run 租约未过期、pending 问题未过期;

count = 未答问题数,questionId = 最早一条(点进去先答它);title 是 Task key。

plan_review 组 status=active 且 plan_hold=true;taskId/runId 空串,title 是组 goal,

status 固定 "active"。

interrupted Task running、当前 run 已不是有效存活(读侧派生)。稳定可造的形状是

「run 仍 running 但 lease_until 已过」;run 已翻成 complete/failed 的会被调度对账

先改写成 Task failed,一般见不到这一类。title 是 Task key,status 固定 "interrupted"。

delivery_failed 组 delivery_status='failed';title 是组 goal,status 是组状态。

不适用的字段给空串(不是省键);排序 updatedAt 升序,同刻按 kind → taskId → orchestrationId 兜底。

同一项目同时命中三类时的真实响应(2026-11-11 隔离引擎实录,三条 item 的关键字段):

{"kind":"delivery_failed","orchestrationId":"or_…","title":"停组后不可修订","count":1,"status":"active"}

{"kind":"plan_review","orchestrationId":"or_…","title":"停组后不可修订","count":1,"status":"active"}

{"kind":"interrupted","taskId":"at_…","title":"C","runId":"r_…","status":"interrupted"}

未知项目 → 404 {"code":114001,"message":"找不到这个项目","data":null}。

═══ 用例 55:通知详情(doc/73 §4.1)—— 机器判红:expected.json 55-notification-detail(needs=pg)═══

引擎以 -task-interval=-1s 起(调度循环关,详情用例造态期间通知不会被抢先认领)。

造态几何(SQL 直写):Task completed 带结果 → 组 finished + delivery_status=failed +

delivery_error_code=delivery_run_error → 一条 error 的旧 run → 通知 failed(claim_run_id=旧 run、

consume_error_code=delivery_run_error)→ 一条 attempt 行。真实响应(2026-11-11 隔离引擎 8943):

curl -s "B/api/notifications/B/api/notifications/NID" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"notificationId":"an_…","orchestrationId":"or_…","taskId":"at_…", "kind":"orchestration_finished","status":"failed","runId":"ra_…","attempt":1, "errorCode":"delivery_run_error", "result":{"finalTaskId":"at_…","resultRevision":1,"summary":"交付摘要正文","artifacts":[]}, "createdAt":"…","claimedAt":"…","failedAt":"…","consumedAt":null,"updatedAt":"…", "attempts":[{"runId":"ra_…","attempt":1,"status":"error","createdAt":"…"}],"backgroundJobId":""}}

data 键序固定十六键:notificationId → orchestrationId → taskId → kind → status → runId → attempt

→ errorCode → result → createdAt → claimedAt → failedAt → consumedAt → updatedAt → attempts

→ backgroundJobId。末位 backgroundJobId 是 doc/82 §6.5 追加(旧字段不重排):编排类通知恒空串,

只有 kind=bash_job_finished 才带命令号,前端据此打开命令详情。

result 只在 kind=orchestration_finished 时给出:finalTaskId + resultRevision 现读组的最终 Task,

摘要与产物从该 Task 的持久结果读,不用通知快照;其它 kind 的 result 恒 null。

attempts 按 attempt 升序,status 现读自 runs(尝试表不复制执行状态);没处理过 = []。

未认领的 pending 通知(task_failed):runId 空串、attempt 0、result null、三个时间 null

curl -s "B/api/notifications/B/api/notifications/NID2" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"notificationId":"ab_…","orchestrationId":"or_…","taskId":"at_…", "kind":"task_failed","status":"pending","runId":"","attempt":0,"errorCode":"","result":null, "createdAt":"…","claimedAt":null,"failedAt":null,"consumedAt":null,"updatedAt":"…","attempts":[], "backgroundJobId":""}}

可见性链 = 通知 → 编排组 → 来源会话 → 本人在租户内;未知、跨租户、viewer、来源会话软删同形 404

curl -s "$B/api/notifications/an_nope" -H "Authorization: Bearer $T" → 404 {"code":117003,"message":"找不到这条通知","data":null} curl -s "$B/api/notifications/$NID" # 不带 token → 401 {"code":111102,"message":"请先登录","data":null}

viewer 与另一租户账号取同一条 → 404 {"code":117003,"message":"找不到这条通知","data":null}

═══ 用例 56:人工重试(doc/73 §4.2)—— 机器判红:expected.json 56-notification-retry(needs=pg)═══

同一隔离引擎。只有 failed 且当前 run 已 error/stopped 才允许新建一次尝试;双击、多标签、

多副本都只会得到一场新 run(attempt 由 MAX(attempt)+1 在新事务里算)。真实响应:

pending(调度器还没认领,人工不抢先)→ 409

curl -s -XPOST "B/api/notifications/B/api/notifications/NID2/retry" -H "Authorization: Bearer $T" → 409 {"code":117109,"message":"这条通知现在不能重新处理","data":null}

failed 但来源会话还有活 run(用户正在聊)→ 409(先等它跑完,不打断)

curl -s -XPOST "B/api/notifications/B/api/notifications/NID3/retry" -H "Authorization: Bearer $T" → 409 {"code":112101,"message":"这场会话正在生成,请稍后再试","data":null}

组最终结果声明了产物但文件不可读(路径越界/目录/软链跳根/已删)→ 409,不把缺失产物交付成成功

curl -s -XPOST "B/api/notifications/B/api/notifications/NID4/retry" -H "Authorization: Bearer $T" → 409 {"code":117110,"message":"结果产物已不可读取","data":null}

已 claimed 且那场 run 仍在跑(双击 / 多副本第二次)→ 200 现状,不开新 run

curl -s -XPOST "B/api/notifications/B/api/notifications/NID5/retry" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"notificationId":"ae_…","runId":"rm_…","status":"claimed","attempt":1}}

claimed 但 claim run 已终态(矛盾态,等对账收口)→ 409

curl -s -XPOST "B/api/notifications/B/api/notifications/NID5/retry" -H "Authorization: Bearer $T" → 409 {"code":117109,"message":"这条通知现在不能重新处理","data":null}

failed + run error → 202 新建 attempt=2(data 键序 notificationId → runId → status → attempt)

curl -s -XPOST "B/api/notifications/B/api/notifications/NID/retry" -H "Authorization: Bearer $T" → 202 {"code":0,"message":"","data":{"notificationId":"an_…","runId":"r_…","status":"claimed","attempt":2}}

未知 / 跨租户 → 404;viewer 被路由角色门先挡 → 403(与 GET 的 404 不同:重试是写操作)

curl -s -XPOST "$B/api/notifications/an_nope/retry" -H "Authorization: Bearer $T" → 404 {"code":117003,"message":"找不到这条通知","data":null} curl -s -XPOST "$B/api/notifications/$NID/retry" -H "Authorization: Bearer $VIEWER" → 403 {"code":111203,"message":"没有权限做这件事","data":null}

另:tenant quota 满 → 429 113001;本用例清单里未造该态(同 note 见 expected.json)。

═══ 用例 57:shared/isolated 创建与通用 workspace 读面(doc/74 §4.1/§4.3)—— 机器判红:expected.json 57-workspace-create-config(needs=pg)═══

同一隔离引擎(调度器关)。创建请求多两个可选字段:workspaceMode(shared/isolated,缺省 shared)

与 verifyCommand(只许 isolated 携带)。shared 的响应字节与 doc/70 时代逐字相同——

单件详情 18 键、不带 workspace;isolated 详情在 updatedAt 之后追加第 19 键 workspace。

curl -s "$B/api/tasks" -X POST -H "Authorization: Bearer $T" \ -d '{"idempotencyKey":"acc57s","workspaceId":"'$WID'","sourceSessionId":"'$SID'","content":"共享单件","agent":"coder"}' → 202 {"code":0,"message":"","data":{"taskId":"at_01…","orchestrationId":"or_01…","status":"ready","currentRunId":""}} curl -s "$B/api/tasks/$TIDS" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"taskId":"at_01…","orchestrationId":"or_01…","key":"main","content":"共享单件", "agent":"coder","modelRef":"","planCheckpoint":false,"createdRevision":0,"workspaceId":"ws_01…","status":"ready", "currentRunId":"","result":null,"error":null,"resultRevision":0,"createdAt":"…","startedAt":null, "finishedAt":null,"updatedAt":"…"}} # 18 键,无 workspace——shared 字节不变 curl -s "$B/api/tasks" -X POST -H "Authorization: Bearer $T" \ -d '{"idempotencyKey":"acc57i","workspaceId":"'$WID'","sourceSessionId":"'$SID'","content":"隔离单件","agent":"coder", "workspaceMode":"isolated","verifyCommand":"exit 0"}' → 202 {"code":0,"message":"","data":{"taskId":"at_01…","orchestrationId":"or_01…","status":"ready","currentRunId":""}} curl -s "$B/api/tasks/$TIDI" -H "Authorization: Bearer $T" → 200 …18 键同形…,"updatedAt":"…","workspace":{"mode":"isolated","provider":"pending", "verification":{"configured":true,"status":""},"publication":{"status":"","errorCode":"","epoch":0}}}

workspace 四键序 mode → provider → verification → publication;verification 两键 configured → status

(证据收尾后才追加 exitCode → outputPath,见用例 58);publication 三键 status → errorCode → epoch。

创建后未执行:provider=pending(组目录还没建)、verification.status=""、publication 全零值。

组体同形(orchestration 16 键 + 末尾 workspace):

curl -s "B/api/orchestrations/B/api/orchestrations/OIDI" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"orchestration":{…"workspace":{"mode":"isolated","provider":"pending", "verification":{"configured":true,"status":""},"publication":{"status":"","errorCode":"","epoch":0}}},"tasks":[…]}}

配置错误 400 117111,原因进 data.reason(三种各钉一条):

curl -s "$B/api/tasks" -X POST … -d '{…"workspaceMode":"bogus",…}' → 400 {"code":117111,"message":"工作区配置不合法","data":{"reason":"workspaceMode 只允许 shared 或 isolated"}} curl -s "$B/api/tasks" -X POST … -d '{…"workspaceMode":"shared","verifyCommand":"exit 0",…}' → 400 {"code":117111,"message":"工作区配置不合法","data":{"reason":"共享工作区不接受 verifyCommand"}} curl -s "$B/api/tasks" -X POST … -d '{…"workspaceMode":"isolated","verifyCommand":"<4001 字节>",…}' → 400 {"code":117111,"message":"工作区配置不合法","data":{"reason":"verifyCommand 超过 4000 字节"}}

同键换计划(isolated 键 acc57i 再发 shared 形状)→ 409 117102(与用例 50 同一幂等冲突):

→ 409 {"code":117102,"message":"这个创建键已经用于另一份计划","data":null}

发布标记期间同项目新 run 被准入挡下(SQL 把 workspaces.publication_orchestration_id 置为某组 id):

curl -s "$B/api/runs" -X POST -H "Authorization: Bearer $T" -d '{"sessionId":"'$SID'","content":"插一脚"}' → 409 {"code":117113,"message":"项目正在发布结果,请稍后再试","data":null}

117113 在 assembleRun 之后、AcquireRun 的准入事务里判——所以租户必须已配模型,否则先撞 111408。

验完把标记清回 ''(列 NOT NULL DEFAULT '',不是 NULL)。

═══ 用例 58:artifact 读不可变结果(doc/74 §4.4)—— 机器判红:expected.json 58-task-artifact(needs=pg)═══

同一隔离引擎。SQL 把隔离单件置 succeeded(result 声明 report.md/gone.md 两件产物、result_revision=1、

execution_session_id 落来源会话),seed_group 在组目录造不可变结果:report.md 有文件、gone.md 只在清单

(模拟文件缺失),verification/.json 记 passed/exit 0 + 输出文件。真实响应:

curl -s "B/api/tasks/B/api/tasks/TIDI" -H "Authorization: Bearer $T" → 200 …"workspace":{"mode":"isolated","provider":"directory", "verification":{"configured":false,"status":"passed","exitCode":0,"outputPath":"verification/at_01….out"}, "publication":{"status":"","errorCode":"","epoch":0}}}

configured=false:这件没配 verifyCommand,passed 是「无验证命令视为通过」的收尾证据;

exitCode/outputPath 只在 status=passed/failed 时出现,键序恒 configured → status → exitCode → outputPath。

成功 = 原始字节逐字回(不进 JSON 信封;Content-Type 按扩展名,.md → text/plain; charset=utf-8):

curl -s "B/api/tasks/B/api/tasks/TIDI/artifact?path=report.md" -H "Authorization: Bearer $T" → 200 隔离结果正文第一行\n第二行 with spaces\n # 逐字节,含末尾换行

清单里有但文件缺失 / 不在清单(../secret)/ 绝对路径(/etc/passwd)→ 一律 409 117110:

curl -s "B/api/tasks/B/api/tasks/TIDI/artifact?path=gone.md" -H "Authorization: Bearer $T" → 409 {"code":117110,"message":"结果产物已不可读取","data":null} curl -s "$B/api/tasks/$TIDI/artifact?path=../secret" -H … → 409 同上 curl -s "$B/api/tasks/$TIDI/artifact?path=/etc/passwd" -H … → 409 同上

shared 件也有不可变结果(doc/76 §5.1):结果在组容器的 results/ 里固化,读口与 isolated 相同;

件没有结果版本(result_revision=0 / 结果引用不可解析)→ 409 117110:

curl -s "B/api/tasks/B/api/tasks/TIDS/artifact?path=report.md" -H "Authorization: Bearer $T" → 409 {"code":117110,"message":"结果产物已不可读取","data":null}

未知件 → 404 117001;未登录 → 401 111102;跨租户(另一账号的 token 读这件)→ 404 117001:

curl -s "$B/api/tasks/at_nope/artifact?path=report.md" -H … → 404 {"code":117001,"message":"找不到这件任务","data":null} curl -s "$B/api/tasks/$TIDI/artifact?path=report.md"(不带 Authorization) → 401 {"code":111102,"message":"请先登录","data":null}

═══ 用例 59:人工重新发布 retry-publication(doc/74 §4.5)—— 机器判红:expected.json 59-publication-retry(needs=pg)═══

同一隔离引擎。前置:隔离单件 succeeded、result_revision=1、组目录有有效不可变结果,

SQL 造「发布受阻」现场(task status=blocked + publication 三码 workspace_changed、组 active +

publication_status=blocked、publication_epoch=1)。真实响应:

curl -s "B/api/tasks/B/api/tasks/TIDI/retry-publication" -X POST -H "Authorization: Bearer $T" → 202 {"code":0,"message":"","data":{"taskId":"at_01…","runId":"r_01…","status":"running","publicationEpoch":2}}

data 四键序 taskId → runId → status → publicationEpoch;epoch=当前+1,新处理 run 在来源会话里铸。

已有活 run(current_run_id 指向 running+活租约)再发 → 200 幂等命中,不开新 run:

→ 200 {"code":0,"message":"","data":{"taskId":"at_01…","runId":"r_01…(同一场)","status":"running","publicationEpoch":2}}

租户容量满(max_concurrent_runs=1 且另一场活 run 占着,注意占额 run 不能在执行会话里——

那会先撞「blocked 但会话有活 run」的矛盾检查 117112)→ 429:

→ 429 {"code":113001,"message":"同时在跑的任务已达上限,请稍后再试","data":null}

结果缺失(result_revision=0)→ 409 117110;非 blocked(succeeded)→ 409 117112;

shared 件但当前不是 blocked(ready)→ 同样 409 117112(shared 与 isolated 同判据:

blocked+发布三码的 shared 最终 Task 走上面的 202 路径,见 doc/76 §10.5 第 3 条):

→ 409 {"code":117110,"message":"结果产物已不可读取","data":null} → 409 {"code":117112,"message":"这件任务现在不能重新发布","data":null}

未知件 → 404 117001;viewer → 403 111203(写操作过角色门);跨租户 → 404 117001:

curl -s "$B/api/tasks/at_nope/retry-publication" -X POST -H … → 404 {"code":117001,"message":"找不到这件任务","data":null} curl -s "$B/api/tasks/$TIDI/retry-publication" -X POST -H "Authorization: Bearer $VIEWER" → 403 {"code":111203,"message":"没有权限做这件事","data":null}

═══ 用例 60:模型执行、Provider 故障与崩溃场景(doc/74 §12.3)—— 声明但暂不断言 ═══

并行成功/父冲突/验证返工/主分支前进/不可变产物/非 Git 并行/结果清单/同路径冲突/

部分发布恢复/忙脏受阻/人工重新发布全链/多标签页事件/各窗口 kill -9 与双副本对账——

都要真模型+真 Git/文件现场+特殊起引擎才造得出,core tier 没有对应 HTTP 路径。

判红在 scripts/acceptance/workspace_git_live.sh、workspace_directory_live.sh、

workspace_publication_live.sh、workspace_crash_live.sh;纯函数与存储侧由 go test 的

workspace_*_test.go 钉住。登记于 expected.json 的 declared_not_asserted["用例 60"]。

═══ 用例 61:继任组创建与 handoff(doc/75 §4.1/§4.3)—— 机器判红:expected.json 61-goal-replan(needs=pg)═══

同一隔离引擎。前置:两个项目都先 GET files(建布局);原组 isolated、单任务 a 已 succeeded、

result_revision=1,组容器里有不可变结果(seed_group 造 result.json + artifacts/report.md)。

建继任组(换到第二个项目、复用 a/1 的结果)。真实响应:

curl -s "B/api/orchestrations/B/api/orchestrations/ORI/successors" -X POST -H "Authorization: Bearer $T" -d '{ "idempotencyKey":"acc61s", "goalAssessment":{"outcome":"feasible","evidence":"旧结果仍有效"}, "reason":"局部换路","successorReason":"复用旧产出", "reuse":[{"taskId":"'$TIDA'","resultRevision":1}], "workspaceId":"'$W2'","workspaceMode":"isolated","goal":"用旧产出重做", "tasks":[{"key":"b","content":"基于 report.md 重做","agent":"researcher"}]}' → 202 {"code":0,"message":"","data":{"orchestrationId":"or_01…","status":"active","replanOf":"or_01…","replanDepth":1}}

data 四键序 orchestrationId → status → replanOf → replanDepth。原组没有活任务:handoff 完整后

原组直接 cancelled、继任组 active(原组还有 running 时是 waiting_previous,见 doc/75 §4.2)。

同键同方案重打 → 202,回读同一个继任组(不建第二组):

→ 202 {"code":0,"message":"","data":{"orchestrationId":"or_01…(同一组)","status":"active","replanOf":"or_01…","replanDepth":1}}

同键换方案(goal 改成「换一个目标」)→ 409:

→ 409 {"code":117102,"message":"这个创建键已经用于另一份计划","data":null}

原组已有继任者后再建 → 409:

→ 409 {"code":117114,"message":"这个编排组现在不能创建继任组","data":null}

方案不合法(可行性判定不是 feasible/缺重规划原因)→ 400 117115,原因进 data.reason:

→ 400 {"code":117115,"message":"继任方案不合法","data":{"reason":"目标可行性判定必须是 feasible 才能创建继任组(当前 "不确定")"}} → 400 {"code":117115,"message":"继任方案不合法","data":{"reason":"重规划原因必填"}}

读交接(机器字段来自 successor.json,正文由程序按模型声明渲染,不从正文反解析):

curl -s "B/api/orchestrations/B/api/orchestrations/SUC/handoff" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"orchestrationId":"or_01…","replanOf":"or_01…","replanDepth":1, "reuse":[{"taskId":"at_01…","resultRevision":1}], "body":"\n# 为什么重规划\n\n局部换路\n\n# 为什么创建继任组\n\n复用旧产出\n\n程序记录的工作区配置变更(其余配置沿用原组):\n- 目标项目改为 ws_01…\n\n# 目标可行性证据\n\n旧结果仍有效\n\n# 哪些结果仍有效\n\n- at_01…(resultRevision 1);产物:report.md\n\n# 不得重放的动作\n\n(模型没有声明不可重放的动作)\n\n以上由模型声明,程序未验证,也不会自动重放。\n"}}

data 五键序 orchestrationId → replanOf → replanDepth → reuse → body。

继任组详情在现有字段末尾追加 replanOf/replanDepth(非继任组没有这两个键):

curl -s "B/api/orchestrations/B/api/orchestrations/SUC" -H "Authorization: Bearer $T" → 200 …"workspace":{"mode":"isolated",…},"replanOf":"or_01…","replanDepth":1}, "tasks":[…],"links":[]}

从继任组再建继任组 → replanDepth=2;对原组再建(另一个键)→ 117114(上一段同码)。

原组没有自己的交接文件 → 404 117004;未知组 → 404 117002:

curl -s "B/api/orchestrations/B/api/orchestrations/ORI/handoff" -H … → 404 {"code":117004,"message":"找不到这次重规划交接","data":null} curl -s "$B/api/orchestrations/or_nope/handoff" -H … → 404 {"code":117002,"message":"找不到这个编排组","data":null}

未登录 → 401 111102;viewer(有身份、角色不够)→ 403 111203:

curl -s "B/api/orchestrations/B/api/orchestrations/ORI/successors" -X POST(不带 Authorization)→ 401 {"code":111102,"message":"请先登录","data":null} curl -s "B/api/orchestrations/B/api/orchestrations/ORI/successors" -X POST -H "Authorization: Bearer $VIEWER" → 403 {"code":111203,"message":"没有权限做这件事","data":null}

═══ 用例 62:项目内容目录与可见性(doc/76 §4/§5)—— 机器判红:expected.json 62-project-layout(needs=pg)═══

同一隔离引擎。seed_ws 按逻辑路径造文件:content/docs/readme.md、content/hello.txt、

runtime/media/note.txt(逻辑 .media/note.txt)、runtime/tmp/bash/out.txt(逻辑 .tako/bash/out.txt)。

文件清单只枚举 content,目录在前、runtime 不列:

curl -s "B/api/workspaces/B/api/workspaces/W/files" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"path":".","entries":[ {"name":"docs","kind":"dir"}, {"name":"hello.txt","kind":"file","size":6,"modifiedAt":"2026-11-12T…"}]}}

媒体占位路径逐字不变(.media/…),物理字节在 runtime/media;项目内普通路径按 content 读:

curl -s "B/api/media?path=workspaces/B/api/media?path=workspaces/W/.media/note.txt" -H "Authorization: Bearer $T" → 200 媒体正文\n(原始字节) curl -s "$B/api/media?path=workspaces/$W/hello.txt" -H … → 200 hello\n(原始字节)

runtime 不提供用户读面:清单与媒体两条路都 404:

curl -s "B/api/workspaces/B/api/workspaces/W/files?path=runtime" -H … → 404 {"code":114101,"message":"找不到这个文件","data":null} curl -s "B/api/media?path=workspaces/B/api/media?path=workspaces/W/runtime/media/note.txt" -H … → 404 {"code":114101,"message":"找不到这个文件","data":null}

旧布局项目(容器非空、没有 layout.json)不自动认成 content,四个入口一致要求迁移:

curl -s "B/api/workspaces/B/api/workspaces/W3/files" -H … → 409 {"code":117116,"message":"这个项目还需要迁移目录后才能使用","data":null} POST /api/tasks(workspaceId=W3)→409同上;POST/api/orchestrations(workspaceId=W3)→ 409 同上;POST /api/orchestrations(workspaceId=W3)→ 409 同上; GET /api/media?path=workspaces/$W3/.media/note.txt → 409 同上。

═══ 用例 63:项目删除 cleanup=done/pending(doc/76 §6.4)—— 机器判红:expected.json 63-project-delete-cleanup(needs=pg)═══

同一隔离引擎。删干净(容器、会话私有目录都清了)→ 成功体在 status 后加 cleanup:

curl -s "B/api/workspaces/B/api/workspaces/W" -X DELETE -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"status":"deleted","cleanup":"done"}}

业务删除已提交:再读 / 再删都是 404(同一信封,不是第二套码):

curl -s "B/api/workspaces/B/api/workspaces/W/files" -H … → 404 {"code":114001,"message":"找不到这个项目","data":null} curl -s "B/api/workspaces/B/api/workspaces/W" -X DELETE -H … → 404 同上

删不干净(容器目录 0555,物理清理失败):业务删除照常完成,只把清理记录留 pending,

不谎报已清完、也不回滚删除:

curl -s "B/api/workspaces/B/api/workspaces/WP" -X DELETE -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"status":"deleted","cleanup":"pending"}}

pending 由调度慢路径继续补偿(本用例起引擎带 -task-interval=-1s,不跑补偿;

补偿与 done 翻转由 scripts/acceptance/project_layout_live.sh 在调度开着的引擎上判红)。

═══ 用例 64:迁移命令、真实模型重规划、Git/Directory 复用与故障场景 —— 声明但暂不断言 ═══

存量项目迁移(-migrate-project-layout)、真模型走「不可行/不确定/同组可修订」的判定、

Git/Directory 两类 Provider 的结果复用、创建各窗口 kill -9、双副本对账与旧 epoch 防写——

都要真模型+真 Git/文件现场+特殊起引擎/双实例才造得出,core tier 没有对应 HTTP 路径。

判红在 scripts/acceptance/project_layout_live.sh、project_layout_migration_live.sh、

goal_replan_live.sh、goal_replan_crash_live.sh;纯函数与存储侧由 go test 的

project_layout_test.go、project_cleanup_test.go、agent_task_successor_test.go 钉住。

登记于 expected.json 的 declared_not_asserted["用例 64"]。

═══ 用例 65:对话页右侧工作区的两个只读读口(doc/78 §4)—— 机器判红:expected.json 65-run-views(needs=pg)═══

同一隔离引擎。seed_ws 造 quote.py、test_quote.py、notes.txt、new.txt、copy.py;

SQL 播一场 run 与五条 tool_call 行:write quote.py、edit test_quote.py、read notes.txt、

bash "echo x > new.txt && cp quote.py copy.py"、write .tako/hidden.txt(应被过滤),

再播三行看板:1 completed、2 in_progress、3 deleted。

改动文件从调用记录派生(与压缩的 file-ops 同一套判定),只列 content 下当前存在的普通文件:

curl -s "B/api/runs/B/api/runs/R/changed-files" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"runId":"r65…","files":[ {"path":"quote.py","op":"write"},{"path":"test_quote.py","op":"edit"}, {"path":"new.txt","op":"write"},{"path":"copy.py","op":"write"}]}}

data 两键序 runId → files;files 每项 path → op,op ∈ write|edit(written/edited 两个桶)。

顺序按首次出现;同一路径再次出现不换位置、op 取最后一次。读类调用(read_file/读媒体/列目录)

不进;.tako/ 与 .media/ 丢弃;越界、content 外的绝对路径、目录、已删除的文件一律不列。

看板读口(deleted 不列、task_no 升序、total=len、done=completed 计数):

curl -s "B/api/runs/B/api/runs/R/tasks" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"runId":"r65…","rows":[ {"no":1,"subject":"实现报价计算","status":"completed","description":"","result":"读取两份文件并生成 quote.py","skillName":"","updatedAt":"2026-11-13T…"}, {"no":2,"subject":"跑单测","status":"in_progress","description":"","result":"","skillName":"","updatedAt":"2026-11-13T…"}], "total":2,"done":1}}

data 四键序 runId → rows → total → done;行内七键序 no → subject → status → description → result → skillName → updatedAt。

没有调用记录 / 会话没挂项目 → 200,数组是 [](不是 null):

→ 200 {"code":0,"message":"","data":{"runId":"r…","files":[]}} → 200 {"code":0,"message":"","data":{"runId":"r…","rows":[],"total":0,"done":0}}

旧布局项目:changed-files 与 /files 同判据回 409;tasks 不读盘,照常 200 空看板:

→ 409 {"code":117116,"message":"这个项目还需要迁移目录后才能使用","data":null} → 200 {"code":0,"message":"","data":{"runId":"r…","rows":[],"total":0,"done":0}}

乱编 runId 与看不见的 run 同字节;不带 token → 401;viewer(租户内但看不见私有会话)→ 404:

curl -s "$B/api/runs/r_nope/changed-files" -H … → 404 {"code":112002,"message":"找不到这次运行","data":null} curl -s "$B/api/runs/r_nope/tasks" -H … → 404 同上 curl -s "B/api/runs/B/api/runs/R/changed-files"(不带 Authorization)→ 401 {"code":111102,"message":"请先登录","data":null} curl -s "B/api/runs/B/api/runs/R/tasks"(不带 Authorization)→ 401 同上 curl -s "B/api/runs/B/api/runs/R/changed-files" -H "Authorization: Bearer $VIEWER" → 404 同上 curl -s "$B/api/runs/$R/tasks" -H "Authorization: Bearer $VIEWER" → 404 同上

═══ 用例 80:任务列表按会话过滤(doc/80 §4.2/§4.3)—— 机器判红:expected.json 80-tasks-session-filter(needs=pg)═══

同一隔离引擎。POST /api/workspaces 建项目;SQL 造两场来源会话(同一项目、同一用户):

INSERT INTO sessions (id,title,tenant_id,user_id,visibility,workspace_id,kind,created_at)

SELECT 'sa'||substring('{wid}' from 3),'scope A','{ten}',id,'private','{wid}','chat',now()

FROM users WHERE email='{email}' RETURNING id → SA(同形再建 'sb'… → SB)

POST /api/tasks 各派一件(acc80a 挂 SA、acc80b 挂 SB);SQL 固定 created_at

(B=2026-01-02、A=2026-01-01)钉住列表的 createdAt 倒序。会话归属记在编排组上

(agent_orchestrations.source_session_id),Task 行本身没有会话列。

curl -s "B/api/workspaces/B/api/workspaces/W/tasks" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"tasks":[ {"taskId":"{tidB}",…,"content":"会话 B 派发的任务",…,"createdAt":"2026-01-02T08:00:00+08:00"}, {"taskId":"{tidA}",…,"content":"会话 A 派发的任务",…,"createdAt":"2026-01-01T08:00:00+08:00"}]}}

不传参数 = 全部,两件都在,顺序不变。

curl -s "B/api/workspaces/B/api/workspaces/W/tasks?sessionId=$SA" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"tasks":[{"taskId":"{tidA}",…,"content":"会话 A 派发的任务"}]}}

非空 sessionId = 只返回「所属编排组 source_session_id 等于它」的 Task。

curl -s "B/api/workspaces/B/api/workspaces/W/tasks?sessionId=$SB" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"tasks":[{"taskId":"{tidB}",…,"content":"会话 B 派发的任务"}]}}

四条都带 data 单键序 tasks;data.tasks 逐位比对(长度必须相同)。

curl -s "B/api/workspaces/B/api/workspaces/W/tasks?sessionId=s_nope" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"tasks":[]}}

未知会话(不存在/已删/不是本人)= 200 空列表,不报 404——读面的缩小范围参数不校验存在性。

空串 sessionId= 与不传同字节 = 全部(两条):

curl -s "B/api/workspaces/B/api/workspaces/W/tasks?sessionId=" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"tasks":[{"taskId":"{tidB}"…},{"taskId":"{tidA}"…}]}}

═══ 用例 82:后台命令的四端点(doc/82 §6.3)—— 机器判红:expected.json 82-jobs-endpoints(needs=pg)═══

同一隔离引擎。POST /api/workspaces 建项目;SQL 造一场来源会话;seed_ws 造输出文件

runtime/tmp/bash/jobs/bj_acc82/stdout.out(逻辑 .tako/bash/jobs/bj_acc82/stdout.out);

SQL 造一行 running 的 background_jobs(backgrounded=true,输出路径按 job 固定目录)。

这四端点的 shape 是 doc/82 §6.3 定死的 jobView(16 键)/ jobOutputView(7 键)/ jobStopView(3 键);

下面字节是 2026-11-15 在隔离引擎(/tmp/yktako-acc)实打抄下来的。

列表:默认只含 backgrounded=true 或 status ∈ {running, stopping} 的行;键序固定:

curl -s "B/api/workspaces/B/api/workspaces/W/jobs" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"jobs":[ {"jobId":"bj_acc82","workspaceId":"ws_…","sourceSessionId":"s_…","sourceRunId":"r_acc82", "sourceTaskId":"","sourceOrchestrationId":"","status":"running","exitCode":null, "stopRequested":false,"backgrounded":true,"command":"echo hello-82", "stdoutPath":"runtime/tmp/bash/jobs/bj_acc82/stdout.out", "stderrPath":"runtime/tmp/bash/jobs/bj_acc82/stderr.out", "createdAt":"…","startedAt":"…","endedAt":null}]}}

详情 jobView 与列表行同形同序(16 键,后三键 createdAt→startedAt→endedAt):

curl -s "$B/api/jobs/bj_acc82" -H "Authorization: Bearer $T" → 200 同上那个单行对象放在 data 位。

/output 读两路文件的当前尾部:stdout 是 seed 的 9 字节、stderr 文件不存在 → 空串;路径恒给:

curl -s "$B/api/jobs/bj_acc82/output" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"jobId":"bj_acc82","status":"running","exitCode":null, "stdout":"hello-82\n","stderr":"", "stdoutPath":"runtime/tmp/bash/jobs/bj_acc82/stdout.out", "stderrPath":"runtime/tmp/bash/jobs/bj_acc82/stderr.out"}}

停止三态:running → stopping+true(本步只写库,杀进程组在 doc/82 步骤 2);仍 stopping → 409 117118;

终态(SQL 收成 succeeded)后重复停止 200 回当前终态 + stopRequested:false(幂等):

curl -s -X POST "$B/api/jobs/bj_acc82/stop" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"jobId":"bj_acc82","status":"stopping","stopRequested":true}} curl -s -X POST "$B/api/jobs/bj_acc82/stop" -H "Authorization: Bearer $T" → 409 {"code":117118,"message":"这条命令正在停止中,不能重复请求","data":null} (SQL 把 status 收成 succeeded 后) → 200 {"code":0,"message":"","data":{"jobId":"bj_acc82","status":"succeeded","stopRequested":false}}

未知 id / 未知项目 / 无 token(三个读端点属主链不可见统一 404 117117):

curl -s "$B/api/jobs/bj_nope" -H "Authorization: Bearer $T" → 404 {"code":117117,"message":"找不到这条命令","data":null} curl -s "$B/api/workspaces/ws_nope/jobs" -H "Authorization: Bearer $T" → 404 {"code":114001,"message":"找不到这个项目","data":null} curl -s "$B/api/jobs/bj_acc82"(不带 Authorization) → 401 {"code":111102,"message":"请先登录","data":null}

═══ 用例 83:路径账本端点(doc/82 §10.3)—— 机器判红:expected.json 83-journey-endpoints(needs=pg)═══

同一隔离引擎。POST /api/workspaces 建项目;SQL 造一场来源会话;POST /api/orchestrations

建两节点编排(a → b,researcher/coder)。journey 是只读投影:不落地任何账本行,

初始计划版本由读侧从 created_revision=0 的 Task 合成(revision 0 / reason=initial / added=任务键),

summary.planRevisions = 存储修订号 + 1(含初始版)。键序与 steps[] 形状是 doc/82 §10.3 定死的;

下面字节是 2026-11-15 在隔离引擎实打抄下来的。

curl -s -X POST "$B/api/orchestrations" -H "Authorization: Bearer $T" -H 'Content-Type: application/json'
-d '{"idempotencyKey":"acc83","workspaceId":"'$W'","sourceSessionId":"'$S'", "goal":"两步调研后汇总", "tasks":[{"key":"a","content":"调研主题 A","agent":"researcher"}, {"key":"b","content":"汇总调研结论","agent":"coder"}], "links":[{"parent":"a","child":"b"}]}' → 202 {"code":0,"message":"","data":{"orchestrationId":"or_…","status":"…","finalTaskId":"…"}}

账本:data 五键(orchestrationId → planRevision → summary → steps → relatedOrchestrationIds);

初始步只有一条 plan_revision(at=编排组创建时刻,added 按任务键序):

curl -s "B/api/orchestrations/B/api/orchestrations/O/journey" -H "Authorization: Bearer $T" → 200 {"code":0,"message":"","data":{"orchestrationId":"or_…","planRevision":0, "summary":{"planRevisions":1,"tasksCreated":2,"succeeded":0,"failed":0,"cancelled":0, "blocked":0,"reusedResults":0,"successorGroups":0,"deliveryAttempts":0}, "steps":[{"type":"plan_revision","revision":0,"at":"…","reason":"initial","added":["a","b"]}], "relatedOrchestrationIds":[]}}

未知编排组(不存在/跨租户/不是本人)同形 404 117002:

curl -s "$B/api/orchestrations/or_journey_unknown00000000/journey" -H "Authorization: Bearer $T" → 404 {"code":117002,"message":"找不到这个编排组","data":null}

无 token:

curl -s "B/api/orchestrations/B/api/orchestrations/O/journey"(不带 Authorization) → 401 {"code":111102,"message":"请先登录","data":null}

2026-10-22 重放实录(信封换完后的矩阵重放)

引擎 127.0.0.1:8901(dev.sh),带登录态,租户模型已配。四条用例的期望字节与本篇正文逐字节一致:

# 用例 0:登录(access TTL 15 分钟,跑到一半过期会拿到这个)
POST /api/auth/login → 200 {"code":0,"message":"","data":{"user":{…},"tenant":{…},"accessToken":"…"}}
   过期后 → 401 {"code":111104,"message":"登录已过期,请重新登录","data":null}

# 用例 1:投递 → 轮询 → 定稿
POST /api/runs {"messageId":"m_v6","text":"只回复 ok"}
→ 202 {"code":0,"message":"","data":{"sessionId":"s_01M5FNQESY55…","runId":"r_01M5FNQESYT…","messageId":"m_v6"}}

GET /api/sessions/{sid}(跑中)
→ 200 {"code":0,"message":"","data":{"liveRunId":"r_01M5FNQESYT…","runlogOffset":1,"lastRunStatus":"running","lastRunId":"r_01M5FNQESYT…","workspaceId":null}}

GET /api/sessions/{sid}(定稿后)
→ 200 {"code":0,"message":"","data":{"liveRunId":"","runlogOffset":2,"lastRunStatus":"complete","lastRunId":"r_01M5FNQESYT…","workspaceId":null}}

GET /api/runs/{rid}/frames?eventOffset=0
→ 200 {"code":0,"message":"","data":{"frames":[
     {"eventOffset":1,"kind":"start",…,"messageId":"m_v6"},
     {"eventOffset":2,"kind":"delta",…,"text":"ok"},
     {"eventOffset":3,"kind":"usage",…,"promptTokens":4230,"completionTokens":2,"totalTokens":4232,"window":256000},
     {"eventOffset":4,"kind":"terminal",…,"status":"complete"}
   ],"nextOffset":4,"status":"done"}}

GET /api/sessions/{sid}/log?runlogOffset=0
→ 200 {"code":0,"message":"","data":{"rows":[
     {"runlogOffset":1,"runId":"r_01M5FNQESYT…","role":"user",…,"text":"只回复 ok"},
     {"runlogOffset":2,"runId":"r_01M5FNQESYT…","role":"assistant",…,"text":"ok","usage":{…}}
   ],"nextOffset":2}}

# 用例 2:越界
GET /api/runs/r_01ZZZ…/frames?eventOffset=999
→ 200 {"code":0,"message":"","data":{"frames":[],"nextOffset":999,"status":"gone"}}
GET /api/sessions/{sid}/log?runlogOffset=999
→ 200 {"code":0,"message":"","data":{"rows":[],"nextOffset":999}}

# 用例 3:未知 sessionId / 未知 run
POST /api/runs {"sessionId":"s_nope",…} → 404 {"code":112001,"message":"找不到这场会话","data":null}
GET  /api/sessions/s_nope        → 404 {"code":112001,"message":"找不到这场会话","data":null}
GET  /api/sessions/s_nope/log    → 404 {"code":112001,"message":"找不到这场会话","data":null}
GET  /api/runs/r_nope/frames     → 200 {"code":0,"message":"","data":{"frames":[],"nextOffset":0,"status":"gone"}}
   (未知 run 在 frames 上仍不是 404——19v6-01 §0)

# 用例 4:忙时诚实拒绝(闸 = 把那场 run 拨成 running + 活租约)
POST /api/runs {"sessionId":"s_01M5FNQES…","messageId":"m_busy","text":"急"}
→ 409 {"code":112101,"message":"这场会话正在跑,等它跑完再发","data":null}
   runlog 行数忙拒前 2 → 忙拒后 2(不变——忙拒零痕迹)

变化只有一层壳:data 内层的字段名与顺序与换壳前逐字相同(liveRunId → runlogOffset → lastRunStatus → lastRunId → workspaceId),外面多了 code/message,失败体从 {"error":"…"} 换成数字业务码 + 弹窗文案。