tianshu-mcp 0.1.2 → 0.1.3

package/README.en.md

@@ -29,7 +29,7 @@ Tianshu plays the role of the overall commander; this MCP server is the **schedu
 ```bash
 npm install
 npm run build        # → dist/
-npm test             # 53 tests: unit + stub-agent 3-playbook integration + protocol + cancel/timeout/baseline/params regression
+npm test             # 72 tests: unit + stub-agent 3-playbook integration + protocol + cancel/timeout/baseline/params/config regression
 ```
 
 Register as a Tianshu MCP server (local dev mode):
@@ -75,7 +75,7 @@ run_task(projectPath=D:/xxx/my-app, task=「…task brief…」, agentId=codex,
   - 8 tools, TaskManager state machine / queue / concurrency gate / cancel (kill tree) / event-stream persistence
   - Acceptance engine (git baseline & diff, default-set derivation, command runner, code analysis, report.md/json)
   - fix-loop auto rework + needs_attention; skill self-install
-  - Stub-agent 3 playbooks (good / fix-on-first / never) integration tests + protocol tests — **53/53 green** (incl. R1–R5 cancel/timeout/baseline/params regressions)
+  - Stub-agent 3 playbooks (good / fix-on-first / never) integration tests + protocol tests — **72/72 green** (incl. R1–R5/S1–S6 cancel/timeout/baseline/params/config regressions)
 - **M2 — Real Codex CLI smoke + rework loop** ✅ (2026-09-07)
   - Real `codex exec` completed `run_task → query_task → verify_task` (see [m2-smoke-record.md](docs/m2-smoke-record.md))
   - Real **failure → rework_task → re-verify succeeded** loop ([m2-rework-record.md](docs/m2-rework-record.md), artifacts in `docs/m2-evidence/`)
@@ -86,18 +86,27 @@ run_task(projectPath=D:/xxx/my-app, task=「…task brief…」, agentId=codex,
   - npm name `tianshu-mcp` published: `tianshu-mcp@0.1.1` (`npm view` resolves; `npx -y tianshu-mcp` raises and connects 8 tools, see [dod7-release-record.md](docs/dod7-release-record.md))
   - Real Tianshu-session skill-trigger validation (DoD #8) needs a GUI session (skill self-installed and ready)
 
-## Acceptance remediation (R1–R8, 2026-09-07)
+## Acceptance remediation (R1–R8, 2026-09-07; S1–S6, 2026-09-08)
 
-Per the acceptance-remediation plan, all P1/P2 findings are fixed with regression tests (total **53/53**):
+Per the acceptance-remediation plans, all P1/P2 findings are fixed with regression tests (total **72/72**):
 
 - **R1** ✅ cancel/interrupt state persistence (`cancel_requested → cancelled`, cancelReason/finishedAt/errorType, restart-recoverable, idempotent, bounded shutdown)
-- **R2** ✅ call-level `taskTimeoutMs` wins (adapter no longer overrides); POSIX process-group SIGTERM→SIGKILL with exit polling; Windows `taskkill /T /F`; single kill-tree impl + abort-race guard
-- **R3** ✅ git baseline participates in diff (baseline.head boundary; agent commits don't lose changes; dirty-worktree hash attribution; `--untracked-files=all`)
-- **R4** ✅ params: `round=0` valid; manual verify allocates next round (no overwrite); `extraChecks` append + `checksMode=replace`; `optional` doesn't fail verdict; `baselineRef` validated
-- **R5** ✅ hardcoded paths removed (`{LOCALAPPDATA}` placeholders + platform defaults); mtime+size hot reload for config/profile/projects
-- **R6** ✅ CI matrix win/mac/linux × Node 20/22 all green (run 25); Release version consistency (tag=package=tarball, v0.1.1 draft OK); tarball content check
-- **R7** ✅ real Tianshu loop: host connect (DoD #6) + skill load & MCP tool call + task loop (DoD #8) + npm publish & npx raise (DoD #7) all verified
-- **R8** 🔄 docs synced (ZH/EN + dev-plan checklist); see [remediation-recheck report](.codex/review/2026-09-07-remediation-recheck.md)
+- **R2** ✅ call-level `taskTimeoutMs` wins; POSIX process-group SIGTERM→SIGKILL; Windows `taskkill /T /F`; single kill-tree impl + abort-race guard
+- **R3** ✅ git baseline participates in diff (baseline.head boundary; agent commits don't lose changes; dirty-worktree hash attribution)
+- **R4** ✅ params: `round=0` valid; manual verify allocates next round; `extraChecks` append + `checksMode=replace`; `optional` semantics; `baselineRef` validated
+- **R5** ✅ hardcoded paths removed (`{LOCALAPPDATA}` placeholders); content-stamp hot reload for config/profile/projects
+- **R6** ✅ CI matrix win/mac/linux × Node 20/22 all green; Release version consistency; tarball content check
+- **R7** ✅ real Tianshu serve session (skill load + MCP tool call + stub task loop); npm v0.1.2 published + npx raise connect
+- **R8** ✅ docs synced (ZH/EN + dev-plan checklist); recheck report
+
+Second-round remediation (per `.codex/plans/2026-09-08-second-remediation-plan.md`):
+- **S1** ✅ no-reason cancel lands `cancelled` (independent `cancelRequestedAt`/`abortSource`, no reliance on optional reason)
+- **S2** ✅ normal timeout → `failed(timeout)` + exactly one `timeout_killed` event, fixed order
+- **S3** ✅ tracked pre-dirty net-diff attribution (unchanged staged/unstaged no longer reported as agent changes)
+- **S4** ✅ `verify_task(taskId)` persists real-task metadata (`reportRound`/`verificationSource`/`latestVerificationVerdict`, keeps agentId); single-source MCP version (build-injected, live-tested = 0.1.2)
+- **S5** ✅ config/profiles/projects last-known-good + sha256 invalidation (fixed corrupt-JSON-reset bug)
+- **S6** ✅ CI/Release npm ci retry corrected; Vitest v3 upgrade (audit 0); plain-text status markers (emoji scan test)
+- **S7/S8/S9** full real-loop evidence & new release pending final close-out (see `.codex/review/`)
 
 ## Recommended phrasing (for Tianshu)
 

package/README.md

@@ -29,7 +29,7 @@ TypeScript · Node.js ≥ 20 · `@modelcontextprotocol/sdk`（stdio）
 ```bash
 npm install
 npm run build        # → dist/
-npm test             # 53 项测试：单元 + stub-agent 三剧本集成 + 协议 + 取消/超时/基线/参数回归
+npm test             # 72 项测试：单元 + stub-agent 三剧本集成 + 协议 + 取消/超时/基线/参数/配置回归
 ```
 
 配置为天枢 MCP server（本地开发模式）：
@@ -76,7 +76,7 @@ run_task(projectPath=D:/xxx/my-app, task=「…任务书…」, agentId=codex, a
   - 8 工具、TaskManager 状态机/队列/并发闸/cancel(kill tree)/事件流落盘
   - 验收引擎（git 基线/diff、默认集推导、命令 runner、代码分析、report.md/json）
   - fix-loop 自动返修 + needs_attention；技能自检安装（已在本机真实 `~/.rivet/skills` 验证）
-  - stub-agent 三剧本（good/fix-on-first/never）集成测试 + 协议测试，**53/53 绿**（含 R1–R5 取消/超时/基线/参数回归）
+  - stub-agent 三剧本（good/fix-on-first/never）集成测试 + 协议测试，**72/72 绿**（含 R1–R5/S1–S6 取消/超时/基线/参数/配置回归）
 - **M2 — 真实 Codex CLI 冒烟 + rework 闭环** ✅（2026-09-07）
   - 真实 `codex exec` 跑通 `run_task → query_task → verify_task`（[m2-smoke-record.md](docs/m2-smoke-record.md)）
   - 真实 **失败→rework_task→再验收 succeeded** 闭环（[m2-rework-record.md](docs/m2-rework-record.md)，物证 `docs/m2-evidence/`）
@@ -94,18 +94,25 @@ run_task(projectPath=D:/xxx/my-app, task=「…任务书…」, agentId=codex, a
   - **npm 已发布**：`tianshu-mcp@0.1.1`（`npm view` 可查，`npx -y tianshu-mcp` 拉起 8 工具连通，见 [dod7-release-record.md](docs/dod7-release-record.md)）
   - GUI 聊天会话内实际调用工具（DoD #8 最后一环）需用户开天枢新会话（宿主连通与 8 工具注册已就位）
 
-## 验收整改（R1–R8，2026-09-07）
-
-按 [验收修复计划](.zcode/plans/tianshu-mcp-development-plan.md) 与 `.codex/plans/2026-09-07-acceptance-remediation-plan.md` 完成：
+## 验收整改（R1–R8，2026-09-07；S1–S6，2026-09-08）
 
 - **R1** ✅ 取消/中断状态机持久化：运行中取消 `cancel_requested → cancelled`（cancelReason/finishedAt/errorType 落盘）、重启可恢复、幂等、shutdown 有界等待。
 - **R2** ✅ 调用级 `taskTimeoutMs` 覆盖生效（adapter 不再用 profile 覆盖）、POSIX 进程组 SIGTERM→SIGKILL、Windows taskkill /T /F，kill-tree 单实现。
 - **R3** ✅ Git 基线参与差异计算：以 baseline.head 为边界，agent 提交不丢变更、脏工作区 hash 归因、porcelain 逐文件展开。
 - **R4** ✅ 参数语义：`get_task_report(round=0)` 合法、手动验收分配新轮次不覆盖、`extraChecks` 追加 + `checksMode=replace`、`optional` 不影响 verdict、`baselineRef` 校验。
-- **R5** ✅ 移除路径硬编码（`{LOCALAPPDATA}` 等占位符 + 平台标准候选），config/profile/projects mtime 热加载。
-- **R6** 🔄 CI 矩阵扩到 Windows/macOS/Linux × Node 20/22；Release 版本一致性校验；tarball 内容校验。
-- **R7** 🟡 天枢真实闭环：宿主连通（DoD #6）与技能安装已实测；GUI 会话内工具调用待用户开天枢新会话。
-- **R8** 🔄 文档同步 + 最终复验。
+- **R5** ✅ 移除路径硬编码（`{LOCALAPPDATA}` 等占位符 + 平台标准候选），config/profile/projects 热加载。
+- **R6** ✅ CI 矩阵 Windows/macOS/Linux × Node 20/22 全绿；Release 版本一致性校验；tarball 内容校验。
+- **R7** ✅ 真实 Tianshu serve 会话实测（技能加载 + MCP 工具 + stub 任务闭环）；npm v0.1.2 发布 + npx 拉起连通。
+- **R8** ✅ 文档同步 + 复验报告。
+
+二次整改（按 `.codex/plans/2026-09-08-second-remediation-plan.md`）：
+- **S1** ✅ 无理由取消稳定落 `cancelled`（新增 `cancelRequestedAt`/`abortSource` 独立字段，不依赖可选 reason）。
+- **S2** ✅ 普通超时统一落 `failed(timeout)` + 一次 `timeout_killed` 事件，顺序固定。
+- **S3** ✅ tracked 预脏净差异归因：staged/unstaged 未变文件不再误报为 agent 变更。
+- **S4** ✅ `verify_task(taskId)` 持久化更新原任务元数据（`reportRound`/`verificationSource`/`latestVerificationVerdict`，保留 agentId）；MCP 版本单一来源（build 注入，服务端实测 version=0.1.2）。
+- **S5** ✅ config/profiles/projects 热加载 last-known-good + 内容 sha256 失效检测（修复损坏 JSON 被当缺失重置的 bug）。
+- **S6** ✅ CI/Release npm ci 重试修正（成功即停/3 次上限/attempt 计数）；Vitest v3 升级（audit 0 漏洞）；纯文本状态标记（emoji 扫描测试）。
+- **S7/S8/S9** 真实完整证据与新版发布待最终闭环（详见 `.codex/review/`）。
 
 ## 推荐用法（给天枢的提示语）
 

package/dist/config/schema.d.ts

@@ -453,6 +453,55 @@ export declare const ProjectRecordSchema: z.ZodObject<{
     defaultAgentId?: string | undefined;
 }>;
 export type ProjectRecord = z.infer<typeof ProjectRecordSchema>;
+/** projects.json 整体文件 schema（S5：不再用对象强制类型转换） */
+export declare const ProjectsFileSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    path: z.ZodString;
+    displayPath: z.ZodOptional<z.ZodString>;
+    firstSeenAt: z.ZodString;
+    lastSeenAt: z.ZodString;
+    verify: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        cmd: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        optional: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        cmd: string | string[];
+        timeoutMs?: number | undefined;
+        optional?: boolean | undefined;
+    }, {
+        name: string;
+        cmd: string | string[];
+        timeoutMs?: number | undefined;
+        optional?: boolean | undefined;
+    }>, "many">>;
+    defaultAgentId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    firstSeenAt: string;
+    lastSeenAt: string;
+    displayPath?: string | undefined;
+    verify?: {
+        name: string;
+        cmd: string | string[];
+        timeoutMs?: number | undefined;
+        optional?: boolean | undefined;
+    }[] | undefined;
+    defaultAgentId?: string | undefined;
+}, {
+    path: string;
+    firstSeenAt: string;
+    lastSeenAt: string;
+    displayPath?: string | undefined;
+    verify?: {
+        name: string;
+        cmd: string | string[];
+        timeoutMs?: number | undefined;
+        optional?: boolean | undefined;
+    }[] | undefined;
+    defaultAgentId?: string | undefined;
+}>>;
+export type ProjectsFile = z.infer<typeof ProjectsFileSchema>;
 export declare const AcceptanceConfigSchema: z.ZodObject<{
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;

package/dist/config/schema.js

@@ -111,6 +111,8 @@ export const ProjectRecordSchema = z.object({
     verify: z.array(AcceptanceCheckSchema).optional(), // 管理员补录的验收配置（可选）
     defaultAgentId: z.string().optional(),
 });
+/** projects.json 整体文件 schema（S5：不再用对象强制类型转换） */
+export const ProjectsFileSchema = z.record(z.string().min(1), ProjectRecordSchema);
 /* ---------------- 项目内 .tianshu-mcp/acceptance.json ---------------- */
 export const AcceptanceConfigSchema = z.object({
     checks: z.array(AcceptanceCheckSchema).default([]),

package/dist/config/store.d.ts

@@ -23,17 +23,21 @@ export declare class DataHome {
     taskDir(taskId: string): string;
     init(): Promise<void>;
     /**
-     * 轻量失效签名：mtime(ms) + 文件大小。同一 mtime tick 内的内容变化（快速 FS/CI）也能被捕获。
-     * 失败返回 "0:0"（每次重读）。
+     * 内容失效签名（S5）：文件内容 sha256。能检测同一 mtime tick 内的同长度修改；
+     * 无法读文件时回退 "0"（每次重读）。
      */
     private fileStamp;
     loadConfig(): Promise<ServerConfig>;
+    /** 读 JSON 且区分"文件不存在"与"JSON 损坏" */
+    private readJsonWithExists;
     saveConfig(cfg: ServerConfig): Promise<void>;
-    /** 用户级 profiles（数据目录）叠加内置 profiles，用户键覆盖内置；按 mtime 轻量热加载（R5） */
+    /** 用户级 profiles（数据目录）叠加内置 profiles，用户键覆盖内置；按内容 stamp 热加载（S5） */
     loadProfiles(): Promise<Record<string, AgentProfile>>;
     saveProfiles(profiles: Record<string, AgentProfile>): Promise<void>;
     /** 供 get_profiles / adapter resolve 使用：返回一份 profile（含内置合并） */
     getProfile(id: string): Promise<AgentProfile | undefined>;
+    /** 解析 projects.json：Zod 校验（S5），解析/校验失败保留上一有效值 */
+    private loadProjectsRaw;
     loadProjects(): Promise<Record<string, ProjectRecord>>;
     registerProject(p: string, defaultAgentId?: string): Promise<{
         hash: string;

package/dist/config/store.js

@@ -5,8 +5,9 @@
 import os from "node:os";
 import path from "node:path";
 import fsp from "node:fs/promises";
-import { AgentProfilesFileSchema, ServerConfigSchema, } from "./schema.js";
-import { readJsonSafe, writeJsonAtomic, mkdirp, readDirSafe, exists } from "../util/fs.js";
+import { AgentProfilesFileSchema, ProjectsFileSchema, ServerConfigSchema, } from "./schema.js";
+import { writeJsonAtomic, mkdirp, readDirSafe, exists } from "../util/fs.js";
+import { createHash } from "node:crypto";
 import { projectHash, normPath } from "../util/path.js";
 import { nowIso } from "../util/id.js";
 export function resolveDataHome() {
@@ -76,43 +77,63 @@ export class DataHome {
     }
     /* ---------- config ---------- */
     /**
-     * 轻量失效签名：mtime(ms) + 文件大小。同一 mtime tick 内的内容变化（快速 FS/CI）也能被捕获。
-     * 失败返回 "0:0"（每次重读）。
+     * 内容失效签名（S5）：文件内容 sha256。能检测同一 mtime tick 内的同长度修改；
+     * 无法读文件时回退 "0"（每次重读）。
      */
     async fileStamp(p) {
         try {
-            const st = await fsp.stat(p);
-            return `${st.mtimeMs}:${st.size}`;
+            const buf = await fsp.readFile(p);
+            return createHash("sha256").update(buf).digest("hex");
         }
         catch {
-            return "0:0";
+            return "0";
         }
     }
     async loadConfig() {
         const stamp = await this.fileStamp(this.configPath);
         if (this.configCache && this.configCacheStamp === stamp)
             return this.configCache;
-        const raw = await readJsonSafe(this.configPath);
-        let cfg = ServerConfigSchema.parse({});
-        if (raw != null) {
-            const r = ServerConfigSchema.safeParse(raw);
-            if (r.success) {
-                cfg = r.data;
-                this.configCache = cfg;
+        const { raw, exists: fileExists } = await this.readJsonWithExists(this.configPath);
+        // 文件不存在 → 首次默认
+        if (!fileExists) {
+            const def = ServerConfigSchema.parse({});
+            if (!this.configCache) {
+                this.configCache = def;
                 this.configCacheStamp = stamp;
             }
-            else {
-                // 解析失败保留上一有效配置（R5）
-                this.logger.warn(`config.json 解析失败，保留上一有效配置: ${r.error.message}`);
-                if (this.configCache)
-                    return this.configCache;
-            }
+            return this.configCache;
         }
-        else {
-            this.configCache = cfg;
+        if (raw == null) {
+            // 文件存在但 JSON 损坏 → 保留上一有效配置（S5 last-known-good）
+            this.logger.warn(`config.json JSON 损坏，保留上一有效配置`);
+            if (this.configCache)
+                return this.configCache;
+            return ServerConfigSchema.parse({});
+        }
+        const r = ServerConfigSchema.safeParse(raw);
+        if (r.success) {
+            this.configCache = r.data;
             this.configCacheStamp = stamp;
+            return r.data;
+        }
+        // schema 校验失败 → 保留上一有效配置
+        this.logger.warn(`config.json schema 校验失败，保留上一有效配置: ${r.error.message}`);
+        return this.configCache ?? ServerConfigSchema.parse({});
+    }
+    /** 读 JSON 且区分"文件不存在"与"JSON 损坏" */
+    async readJsonWithExists(p) {
+        try {
+            const text = await fsp.readFile(p, "utf8");
+            try {
+                return { raw: JSON.parse(text), exists: true };
+            }
+            catch {
+                return { raw: null, exists: true };
+            }
+        }
+        catch {
+            return { raw: null, exists: false };
         }
-        return this.configCache ?? cfg;
     }
     async saveConfig(cfg) {
         await writeJsonAtomic(this.configPath, cfg);
@@ -120,7 +141,7 @@ export class DataHome {
         this.configCacheStamp = await this.fileStamp(this.configPath);
     }
     /* ---------- agent-profiles ---------- */
-    /** 用户级 profiles（数据目录）叠加内置 profiles，用户键覆盖内置；按 mtime 轻量热加载（R5） */
+    /** 用户级 profiles（数据目录）叠加内置 profiles，用户键覆盖内置；按内容 stamp 热加载（S5） */
     async loadProfiles() {
         const stamp = await this.fileStamp(this.profilesPath);
         if (this._profilesCache && this._profilesCacheStamp === stamp)
@@ -130,7 +151,16 @@ export class DataHome {
         for (const [k, v] of Object.entries(this.builtinProfiles)) {
             merged[k] = { ...v, id: k };
         }
-        const raw = await readJsonSafe(this.profilesPath);
+        const { raw, exists: fileExists } = await this.readJsonWithExists(this.profilesPath);
+        if (fileExists && raw == null) {
+            // JSON 损坏 → 保留上一有效（若有）；否则仅内置
+            this.logger.warn(`agent-profiles.json JSON 损坏，保留上一有效 profiles`);
+            if (this._profilesCache)
+                return this._profilesCache;
+            this._profilesCache = merged;
+            this._profilesCacheStamp = stamp;
+            return merged;
+        }
         if (raw != null) {
             const r = AgentProfilesFileSchema.safeParse(raw);
             if (r.success) {
@@ -139,7 +169,7 @@ export class DataHome {
                 }
             }
             else {
-                this.logger.warn(`agent-profiles.json 解析失败，保留上一有效 profiles: ${r.error.message}`);
+                this.logger.warn(`agent-profiles.json 校验失败，保留上一有效 profiles: ${r.error.message}`);
                 if (this._profilesCache)
                     return this._profilesCache;
             }
@@ -166,18 +196,29 @@ export class DataHome {
         return all[id];
     }
     /* ---------- projects 自动登记 ---------- */
+    /** 解析 projects.json：Zod 校验（S5），解析/校验失败保留上一有效值 */
+    async loadProjectsRaw() {
+        const { raw, exists: fileExists } = await this.readJsonWithExists(this.projectsPath);
+        if (!fileExists)
+            return { ok: true, map: {}, missing: true }; // 文件不存在 = 空（首次）
+        if (raw == null)
+            return { ok: false, map: {}, error: "JSON 损坏" };
+        const r = ProjectsFileSchema.safeParse(raw);
+        if (!r.success) {
+            return { ok: false, map: {}, error: r.error.message };
+        }
+        return { ok: true, map: r.data };
+    }
     async loadProjects() {
         const stamp = await this.fileStamp(this.projectsPath);
         if (this.projectsCache && this.projectsCacheStamp === stamp)
             return this.projectsCache;
-        const raw = await readJsonSafe(this.projectsPath);
-        const map = {};
-        if (raw != null && typeof raw === "object") {
-            for (const [hash, v] of Object.entries(raw)) {
-                if (v && typeof v === "object") {
-                    map[hash] = v;
-                }
-            }
+        const { ok, map, error } = await this.loadProjectsRaw();
+        if (!ok) {
+            this.logger.warn(`projects.json 解析失败，保留上一有效 projects: ${error}`);
+            if (this.projectsCache)
+                return this.projectsCache;
+            return {}; // 首次即非法：给空 map（不写入覆盖磁盘）
         }
         this.projectsCache = map;
         this.projectsCacheStamp = stamp;
@@ -195,6 +236,7 @@ export class DataHome {
         projects[hash] = record;
         this.projectsCache = projects;
         await writeJsonAtomic(this.projectsPath, projects);
+        this.projectsCacheStamp = await this.fileStamp(this.projectsPath);
         return { hash, record };
     }
     async updateProjectVerify(hash, verify) {
@@ -205,6 +247,7 @@ export class DataHome {
         rec.verify = verify.map((v) => ({ name: v.name, cmd: v.cmd }));
         this.projectsCache = projects;
         await writeJsonAtomic(this.projectsPath, projects);
+        this.projectsCacheStamp = await this.fileStamp(this.projectsPath);
     }
     async projectByPath(p) {
         const norm = normPath(p);

package/dist/loop/fix-loop.d.ts

@@ -30,9 +30,15 @@ export declare class TaskOrchestrator {
     run(): Promise<OrchestrateResult>;
     private aborted;
     /**
-     * 取消/中断的终态落盘：cancel_requested → cancelled（持久化 errorType/cancelReason/finishedAt）；
-     * 无 cancel_requested（如 server 关闭或未显式取消的 abort）→ interrupted。
-     * 由 orchestrator 在子进程真正关闭后调用，避免只返回游离 status。
+     * 统一超时终态（S2）：落 failed(errorType=timeout) 并记录一次 timeout_killed 事件。
+     * 普通 runRes.timeout 与 abort guard 超时共用此路径，保证事件不重复、顺序固定。
+     */
+    private timeoutTerminal;
+    /**
+     * 取消/中断的终态落盘（S1）：用独立 cancelRequestedAt/abortSource 判断来源，不依赖可选 reason。
+     * - 用户取消（cancelRequestedAt 已置位 / abortSource=user / 排队中）→ cancelled
+     * - server 关闭/EOF/未显式取消的中止 → interrupted
+     * - 超时 → failed(timeout) + timeout_killed（委托 timeoutTerminal）
      */
     private abortTerminal;
     private finish;

package/dist/loop/fix-loop.js

@@ -53,7 +53,8 @@ export class TaskOrchestrator {
                     return this.finish("failed", "spawn", `agent 基础设施失败：${runRes.error ?? "未知"}（日志 ${runRes.logFile}）`);
                 }
                 if (runRes.timeout) {
-                    return this.finish("failed", "timeout", `任务超时（${meta.taskTimeoutMs}ms），进程树已终止。日志 ${runRes.logFile}`);
+                    // S2：统一超时终态 —— 落 failed(timeout) 并记录一次 timeout_killed
+                    return this.timeoutTerminal(`任务超时（${meta.taskTimeoutMs}ms），进程树已终止。日志 ${runRes.logFile}`);
                 }
                 if (runRes.killed) {
                     return this.abortTerminal();
@@ -105,31 +106,47 @@ export class TaskOrchestrator {
         return this.signal?.aborted ?? false;
     }
     /**
-     * 取消/中断的终态落盘：cancel_requested → cancelled（持久化 errorType/cancelReason/finishedAt）；
-     * 无 cancel_requested（如 server 关闭或未显式取消的 abort）→ interrupted。
-     * 由 orchestrator 在子进程真正关闭后调用，避免只返回游离 status。
+     * 统一超时终态（S2）：落 failed(errorType=timeout) 并记录一次 timeout_killed 事件。
+     * 普通 runRes.timeout 与 abort guard 超时共用此路径，保证事件不重复、顺序固定。
      */
-    async abortTerminal() {
+    async timeoutTerminal(reason) {
         if (this.done)
             return { status: this.meta.status, meta: this.meta, reason: this.meta.lastMessage };
         this.done = true;
         const meta = this.meta;
-        if (meta.errorType === "timeout") {
-            // 超时兜底 guard 已标 timeout → 落 failed(timeout)，记录 timeout_killed 事件
-            meta.lastMessage = meta.lastMessage || "任务超时，进程树已终止。";
-            await this.deps.store.updateStatus(meta, "failed", meta.lastMessage);
-            await this.deps.store.appendEvent(meta.taskId, "timeout_killed", "failed", meta.lastMessage).catch(() => { });
-            return { status: "failed", meta, reason: meta.lastMessage, summary: meta.lastMessage };
+        meta.errorType = "timeout";
+        meta.abortSource = "timeout";
+        meta.lastMessage = reason;
+        // 事件顺序固定：先 failed 落盘（含 finishedAt），再记 timeout_killed
+        await this.deps.store.updateStatus(meta, "failed", reason);
+        await this.deps.store.appendEvent(meta.taskId, "timeout_killed", "failed", reason).catch(() => { });
+        return { status: "failed", meta, reason, summary: reason };
+    }
+    /**
+     * 取消/中断的终态落盘（S1）：用独立 cancelRequestedAt/abortSource 判断来源，不依赖可选 reason。
+     * - 用户取消（cancelRequestedAt 已置位 / abortSource=user / 排队中）→ cancelled
+     * - server 关闭/EOF/未显式取消的中止 → interrupted
+     * - 超时 → failed(timeout) + timeout_killed（委托 timeoutTerminal）
+     */
+    async abortTerminal() {
+        if (this.done)
+            return { status: this.meta.status, meta: this.meta, reason: this.meta.lastMessage };
+        if (this.meta.abortSource === "timeout") {
+            return this.timeoutTerminal(this.meta.lastMessage || "任务超时，进程树已终止。");
         }
-        const hadCancelRequest = Boolean(meta.cancelReason) || meta.status === "queued";
-        const isCancelled = hadCancelRequest;
+        this.done = true;
+        const meta = this.meta;
+        // 用户取消判定：cancelRequestedAt 置位 或 显式 user abortSource 或 queued 阶段取消
+        const isCancelled = Boolean(meta.cancelRequestedAt) || meta.abortSource === "user" || meta.status === "queued";
         if (isCancelled) {
             meta.errorType = "cancelled";
+            meta.abortSource = "user";
             meta.lastMessage = meta.cancelReason ? `已取消：${meta.cancelReason}` : "已取消";
             await this.deps.store.updateStatus(meta, "cancelled", meta.lastMessage);
         }
         else {
             meta.errorType = "interrupted";
+            meta.abortSource = "shutdown";
             meta.lastMessage = "任务已中断（server 退出 / 父进程 EOF / 未显式取消的中止）。";
             await this.deps.store.updateStatus(meta, "interrupted", meta.lastMessage);
         }

package/dist/mcp/formatter.d.ts

@@ -27,6 +27,9 @@ export interface MetaBlockFields {
     errorType?: string;
     cancelReason?: string;
     finishedAt?: string;
+    reportRound?: number;
+    verificationSource?: string;
+    latestVerificationVerdict?: string;
 }
 export type ToolResult = {
     content: {

package/dist/mcp/formatter.js

@@ -26,6 +26,9 @@ export function metaFromTask(meta, extra) {
         errorType: meta.errorType ?? undefined,
         cancelReason: meta.cancelReason,
         finishedAt: meta.finishedAt,
+        reportRound: meta.reportRound,
+        verificationSource: meta.verificationSource,
+        latestVerificationVerdict: meta.latestVerificationVerdict,
         ...extra,
     };
 }

package/dist/mcp/handlers.js

@@ -126,9 +126,9 @@ function describeStatus(meta) {
         running: "运行中（agent 正在开发）",
         verify_start: "验收中（自动命令检查 + 代码分析）",
         fixing: "返修中（上一轮验收失败，agent 正在按反馈修改）",
-        succeeded: "✅ 任务成功",
-        failed: "❌ 任务失败",
-        needs_attention: "⚠️ 需要人工介入（自动返修轮次已用尽或可修性存疑）",
+        succeeded: "[PASS] 任务成功",
+        failed: "[FAIL] 任务失败",
+        needs_attention: "[WARN] 需要人工介入（自动返修轮次已用尽或可修性存疑）",
         cancelled: "已取消",
         interrupted: "已中断（server 重启/退出）",
     };
@@ -249,8 +249,9 @@ function verifyTaskHandler(ctx) {
         });
         // round 分配：手动验收写入任务目录时不能覆盖已有 report-0.*，分配下一可用轮次
         const round = await nextReportRound(store, taskId);
+        const verifyTaskId = taskId ?? `vfy_${Date.now()}`;
         const req = {
-            taskId: taskId ?? `vfy_${Date.now()}`,
+            taskId: verifyTaskId,
             projectPath,
             displayPath,
             taskText,
@@ -265,31 +266,57 @@ function verifyTaskHandler(ctx) {
         };
         const { report, passed } = await engine.runVerify(req);
         const head = passed
-            ? `✅ 验收通过（手动验收）：${report.checks.filter((c) => c.passed).length}/${report.checks.length} 项命令检查通过。`
-            : `❌ 验收失败（手动验收）：${report.checks.filter((c) => !c.passed && !c.skipped).length} 项检查未通过。`;
+            ? `[PASS] 手动验收通过（reportRound ${round}）：${report.checks.filter((c) => c.passed).length}/${report.checks.length} 项检查通过。`
+            : `[FAIL] 手动验收失败（reportRound ${round}）：${report.checks.filter((c) => !c.passed && !c.skipped).length} 项检查未通过。`;
         const changed = report.analysis.changedFiles.length + report.analysis.untrackedFiles.length;
-        const meta = {
-            taskId: req.taskId,
-            status: passed ? "succeeded" : "failed",
-            projectPath,
-            displayPath,
-            agentId: "manual-verify",
-            task: taskText ?? "(手动验收)",
-            autoVerify: true,
-            autoFixRounds: 0,
-            taskTimeoutMs: 0,
-            round: 0,
-            roundsUsed: 0,
-            createdAt: report.startedAt,
-            updatedAt: report.finishedAt,
-            lastMessage: head,
-            changedFiles: [...report.analysis.changedFiles, ...report.analysis.untrackedFiles],
-            diffstat: `+${report.analysis.diffstat.totalAdd} -${report.analysis.diffstat.totalDel}`,
-            reportMd: report.files.md,
-            reportJson: report.files.json,
-        };
-        const detailLines = [`${head}`, `变更 ${changed} 个文件，diffstat ${meta.diffstat}。`, `报告：${report.files.md}`, `JSON：${report.files.json}`];
-        return formatToolResult(detailLines.join("\n"), metaFromTask(meta));
+        const diffstat = `+${report.analysis.diffstat.totalAdd} -${report.analysis.diffstat.totalDel}`;
+        // S4：taskId 模式下更新并持久化原任务元数据（保留原 agentId，不改任务终态；新增单独验收结论字段）。
+        let resultMeta;
+        if (taskId) {
+            const real = await manager.getMeta(taskId);
+            if (!real)
+                return errorResult(`任务不存在: ${taskId}`);
+            real.reportRound = round;
+            real.verificationSource = "manual";
+            real.latestVerificationVerdict = passed ? "passed" : "failed";
+            real.reportMd = report.files.md;
+            real.reportJson = report.files.json;
+            real.lastMessage = head;
+            real.changedFiles = [...report.analysis.changedFiles, ...report.analysis.untrackedFiles];
+            real.diffstat = diffstat;
+            real.updatedAt = report.finishedAt;
+            await manager.persistMetaUpdate(real);
+            resultMeta = real;
+        }
+        else {
+            // 独立 projectPath 验收：创建并持久化独立 vfy 记录
+            resultMeta = {
+                taskId: verifyTaskId,
+                status: passed ? "succeeded" : "failed",
+                projectPath,
+                displayPath,
+                agentId: "manual-verify",
+                task: taskText ?? "(手动验收)",
+                autoVerify: true,
+                autoFixRounds: 0,
+                taskTimeoutMs: 0,
+                round: 0,
+                roundsUsed: 0,
+                reportRound: round,
+                verificationSource: "manual",
+                latestVerificationVerdict: passed ? "passed" : "failed",
+                createdAt: report.startedAt,
+                updatedAt: report.finishedAt,
+                lastMessage: head,
+                changedFiles: [...report.analysis.changedFiles, ...report.analysis.untrackedFiles],
+                diffstat,
+                reportMd: report.files.md,
+                reportJson: report.files.json,
+            };
+            await manager.persistMetaUpdate(resultMeta);
+        }
+        const detailLines = [`${head}`, `变更 ${changed} 个文件，diffstat ${resultMeta.diffstat}。`, `报告：${report.files.md}`, `JSON：${report.files.json}`];
+        return formatToolResult(detailLines.join("\n"), metaFromTask(resultMeta));
     };
 }
 function reworkTaskHandler(ctx) {
@@ -320,7 +347,7 @@ function getProfilesHandler(ctx) {
         const rows = [];
         for (const id of ids) {
             const r = await registry.resolve(id, true);
-            const mark = r.ok ? "✅ 可用" : "❌ 不可用";
+            const mark = r.ok ? "[PASS] 可用" : "[FAIL] 不可用";
             rows.push(`${mark}\t${id}\t${r.displayName}\t${r.message}${r.discovered ? ` [探测来源: ${r.discovered.source}]` : ""}`);
         }
         const head = "Agent 适配与可执行探测结果（列: 可用 / agentId / 名称 / 说明）";

package/dist/server.js

@@ -15,6 +15,7 @@ import { makeHandlers } from "./mcp/handlers.js";
 import { TOOL_DEFS } from "./mcp/tools.js";
 import { Logger as LoggerCtor } from "./util/log.js";
 import { skillSelfInstall } from "./util/skill-install.js";
+import { MCP_SERVER_VERSION } from "./version.generated.js";
 export async function buildServer(opts = {}) {
     const home = opts.home ?? resolveDataHome();
     const logger = opts.logger ?? (await LoggerCtor.create(path.join(home, "logs")));
@@ -42,7 +43,7 @@ export async function buildServer(opts = {}) {
         defaultAutoVerify: true,
         defaultAutoFixRounds: 0,
     });
-    const server = new McpServer({ name: "tianshu-mcp", version: "0.1.0" }, {
+    const server = new McpServer({ name: "tianshu-mcp", version: MCP_SERVER_VERSION }, {
         capabilities: { tools: {} },
         instructions: "tianshu-mcp：调度外部 AI-Agent（codex/zcode）完成 项目开发 → 验收 → 返修 闭环。工具返回文本 + ---tianshu-mcp-meta--- JSON 块。run_task 是异步的：先拿 taskId 再用 query_task 轮询。",
     });

package/dist/tasks/task-manager.d.ts

@@ -43,6 +43,8 @@ export declare class TaskManager {
     get activeCount(): number;
     getMaxRunning(): number;
     getMeta(taskId: string): Promise<TaskMeta | null>;
+    /** S4：外部对终态任务元数据的更新（如手动 verify 更新报告指针/轮次）——写快照并同步内存 map */
+    persistMetaUpdate(meta: TaskMeta): Promise<void>;
     listTasks(filter?: {
         projectPath?: string;
         status?: string;
@@ -66,7 +68,7 @@ export declare class TaskManager {
     }>;
     /** server 退出：终止全部活动任务并标 interrupted（排队中任务也归档） */
     shutdownInterrupt(): Promise<void>;
-    /** 有界等待子进程真正关闭后落 interrupted */
+    /** 有界等待子进程真正关闭后落 interrupted（server 关闭路径，不得误记为 cancelled） */
     private persistInterrupted;
     private enqueue;
     /** 该项目当前是否有 running 任务（每项目串行闸） */

package/dist/tasks/task-manager.js

@@ -30,6 +30,7 @@ export class TaskManager {
         for (const meta of legacy) {
             this.tasks.set(meta.taskId, meta);
             meta.errorType = "interrupted";
+            meta.abortSource = "shutdown";
             meta.lastMessage = "server 重启遗留（启动时归档，不续跑）。";
             await this.store.updateStatus(meta, "interrupted", "server 重启遗留归档");
         }
@@ -45,6 +46,11 @@ export class TaskManager {
     async getMeta(taskId) {
         return this.tasks.get(taskId) ?? (await this.store.readSnapshot(taskId));
     }
+    /** S4：外部对终态任务元数据的更新（如手动 verify 更新报告指针/轮次）——写快照并同步内存 map */
+    async persistMetaUpdate(meta) {
+        this.tasks.set(meta.taskId, meta);
+        await this.store.writeSnapshot(meta);
+    }
     async listTasks(filter) {
         let metas = await this.store.listTaskSnapshots();
         if (filter?.projectPath) {
@@ -123,8 +129,14 @@ export class TaskManager {
             }
             meta.status = "cancelled";
             meta.errorType = "cancelled";
+            meta.abortSource = "user";
+            meta.cancelRequestedAt = nowIso();
             meta.cancelReason = reason;
+            meta.finishedAt = meta.cancelRequestedAt;
+            meta.updatedAt = meta.cancelRequestedAt;
             meta.lastMessage = reason ? `已取消（排队中）：${reason}` : "已取消（排队中）";
+            // 追加 cancel_requested 事件后再落 cancelled，保证事件流完整
+            await this.store.appendEvent(meta.taskId, "cancel_requested", "queued", reason ? `收到取消请求：${reason}` : "收到取消请求（无 reason）");
             await this.store.updateStatus(meta, "cancelled", meta.lastMessage);
             return { found: true };
         }
@@ -154,6 +166,7 @@ export class TaskManager {
             if (meta.status === "queued") {
                 meta.status = "interrupted";
                 meta.errorType = "interrupted";
+                meta.abortSource = "shutdown";
                 meta.lastMessage = "server 退出，排队中任务已归档";
                 await this.store.updateStatus(meta, "interrupted", meta.lastMessage).catch(() => { });
                 void taskId;
@@ -163,7 +176,7 @@ export class TaskManager {
         this.runningCount = 0;
         this.queue.clear();
     }
-    /** 有界等待子进程真正关闭后落 interrupted */
+    /** 有界等待子进程真正关闭后落 interrupted（server 关闭路径，不得误记为 cancelled） */
     async persistInterrupted(meta) {
         const deadline = Date.now() + 2000;
         for (;;) {
@@ -176,6 +189,7 @@ export class TaskManager {
         if (ACTIVE_STATUSES.includes(meta.status)) {
             meta.status = "interrupted";
             meta.errorType = "interrupted";
+            meta.abortSource = "shutdown";
             meta.lastMessage = "server 退出，进程已终止";
             await this.store.updateStatus(meta, "interrupted", meta.lastMessage).catch(() => { });
         }
@@ -248,6 +262,7 @@ export class TaskManager {
             if (m && ACTIVE_STATUSES.includes(m.status)) {
                 this.logger.warn(`任务 ${meta.taskId} 超过任务级超时兜底（${meta.taskTimeoutMs}+${KILL_GRACE_MS}ms），标记 timeout 并 abort`);
                 m.errorType = "timeout";
+                m.abortSource = "timeout";
                 m.lastMessage = `任务超时兜底触发（${meta.taskTimeoutMs}ms + ${KILL_GRACE_MS}ms grace）。`;
                 ac.abort();
             }

package/dist/tasks/task-store.d.ts

@@ -21,7 +21,7 @@ export declare class TaskStore {
     readSnapshot(taskId: string): Promise<TaskMeta | null>;
     updateStatus(meta: TaskMeta, status: TaskStatus, detail?: string, eventName?: TaskEvent["event"]): Promise<void>;
     addNote(meta: TaskMeta, detail: string): Promise<void>;
-    /** cancel_requested 事件 + cancelReason 落盘（供后续终态判定 cancelled vs interrupted） */
+    /** cancel_requested 事件 + 独立取消意图字段落盘（S1：不依赖可选 reason 判断取消来源） */
     markCancelRequested(meta: TaskMeta, reason?: string): Promise<void>;
     saveReport(taskId: string, report: VerifyReport): Promise<void>;
     /** 启动扫描：找出 running/interrupted/queued 遗留，供归档 */

package/dist/tasks/task-store.js

@@ -102,11 +102,13 @@ export class TaskStore {
         await this.appendEvent(meta.taskId, "note", meta.status, detail);
         await this.writeSnapshot(meta);
     }
-    /** cancel_requested 事件 + cancelReason 落盘（供后续终态判定 cancelled vs interrupted） */
+    /** cancel_requested 事件 + 独立取消意图字段落盘（S1：不依赖可选 reason 判断取消来源） */
     async markCancelRequested(meta, reason) {
         meta.cancelReason = reason;
-        meta.updatedAt = nowIso();
-        await this.appendEvent(meta.taskId, "cancel_requested", meta.status, reason ? `收到取消请求：${reason}` : "收到取消请求");
+        meta.cancelRequestedAt = nowIso();
+        meta.abortSource = "user";
+        meta.updatedAt = meta.cancelRequestedAt;
+        await this.appendEvent(meta.taskId, "cancel_requested", meta.status, reason ? `收到取消请求：${reason}` : "收到取消请求（无 reason）");
         await this.writeSnapshot(meta);
     }
     /* ---------- 报告 ---------- */

package/dist/tasks/task.d.ts

@@ -98,8 +98,18 @@ export interface TaskMeta {
     reportMd?: string;
     reportJson?: string;
     cancelReason?: string;
+    /** 用户取消意图的独立结构化标记（S1）：一旦用户调用 cancel_task 即置位，不依赖可选 reason 推断 */
+    cancelRequestedAt?: string;
+    /** 中断来源：user=用户取消；shutdown=server 关闭/EOF；timeout=任务超时；internal=内部错误 */
+    abortSource?: "user" | "shutdown" | "timeout" | "internal";
     /** rework_task 注入的追加指示（仅作用于下一轮 agent） */
     reworkFeedback?: string;
+    /** S4：最近一次验收的报告轮次（0-based，reportRound）——区别于 agent roundsUsed */
+    reportRound?: number;
+    /** S4：最近一次验收来源：run_task 自动 / verify_task 手动；不覆盖 agentId */
+    verificationSource?: "auto" | "manual";
+    /** S4：最近一次手动验收结论（不改变 agent 任务终态时单独记录） */
+    latestVerificationVerdict?: "passed" | "failed";
 }
 /** manager 记录任务所需最小信息（内存态），与 TaskMeta 解耦 */
 export interface TaskRecord {

package/dist/verify/code-analysis.js

@@ -30,8 +30,19 @@ export async function analyzeChanges(opts) {
     // 基线前已存在的脏文件集合
     const preChanged = new Set(baseline.preExistingChanged);
     const preUntracked = new Set(baseline.preExistingUntracked);
-    // 相对基线 ref 的已跟踪差异（含 agent 提交前移 + 工作树）
-    const { numstat, changedLinesPerFile } = await diffSinceBaseline(opts.projectPath, baseline.head);
+    // S3：排除"基线前脏且任务期间内容未变化"的 tracked 文件（避免把用户原有改动归因给 agent）。
+    // 对每个基线前脏文件，比较基线内容 hash 与当前工作树内容 hash；一致 = agent 未触碰 → 完全排除。
+    const unchangedPreDirty = new Set();
+    for (const f of [...preChanged]) {
+        const baseHash = baseDirtyHash(baseline, f);
+        if (!baseHash)
+            continue; // 无基线 hash（超大/删除等）不排除，交给 diff 判断
+        const nowHash = await fileHashQuick(path.join(opts.projectPath, f));
+        if (nowHash === baseHash)
+            unchangedPreDirty.add(f);
+    }
+    // 相对基线 ref 的已跟踪差异（含 agent 提交前移 + 工作树）；排除未变化的预脏文件
+    const { numstat, changedLinesPerFile } = await diffSinceBaseline(opts.projectPath, baseline.head, unchangedPreDirty);
     const perFile = [];
     const trackedSeen = new Set();
     // 已跟踪变更：diffSinceBaseline 以 baseline.head 为边界（含 agent 提交前移），净增删为 0 的剔除。
@@ -47,7 +58,7 @@ export async function analyzeChanges(opts) {
             continue;
         const full = path.join(opts.projectPath, f);
         if (preUntracked.has(f)) {
-            const baseHash = baseline.preUntrackedHashes[f];
+            const baseHash = baseDirtyHash(baseline, f);
             const nowHash = await fileHashQuick(full);
             if (baseHash && nowHash && baseHash === nowHash)
                 continue; // 基线前已有且未变：非任务改动
@@ -79,7 +90,7 @@ export async function analyzeChanges(opts) {
     for (const f of parsed.untracked) {
         if (preUntracked.has(f)) {
             const full = path.join(opts.projectPath, f);
-            const baseHash = baseline.preUntrackedHashes[f];
+            const baseHash = baseDirtyHash(baseline, f);
             const nowHash = await fileHashQuick(full);
             if (baseHash && nowHash && baseHash === nowHash)
                 continue;
@@ -102,7 +113,7 @@ export async function analyzeChanges(opts) {
             return true;
         // 基线前已有：内容变了才作为本轮新增未跟踪
         const full = path.join(opts.projectPath, f);
-        const b = baseline.preUntrackedHashes[f];
+        const b = baseDirtyHash(baseline, f);
         const n = fileHashSync(full);
         return !(b && n && b === n);
     });
@@ -159,6 +170,10 @@ async function fileHashQuick(p) {
         return null;
     }
 }
+/** 基线脏文件内容 hash：优先新字段 preDirtyHashes，兼容旧快照回退 preUntrackedHashes */
+function baseDirtyHash(baseline, f) {
+    return baseline.preDirtyHashes?.[f] ?? baseline.preUntrackedHashes?.[f];
+}
 function fileHashSync(p) {
     try {
         const buf = fs.readFileSync(p);

package/dist/verify/git-baseline.d.ts

@@ -6,7 +6,9 @@ export interface Baseline {
     /** 相对动工前 HEAD 的已跟踪变更（基线前已存在） */
     preExistingChanged: string[];
     preExistingUntracked: string[];
-    /** 基线前未跟踪文件的内容 hash（便于区分 agent 是否改动） */
+    /** 基线前脏文件（已跟踪 staged/unstaged + 未跟踪）的内容 hash：区分基线已有内容与 agent 后续改动 */
+    preDirtyHashes: Record<string, string>;
+    /** 基线前未跟踪文件的内容 hash（兼容旧字段，逻辑并入 preDirtyHashes） */
     preUntrackedHashes: Record<string, string>;
     capturedAt: string;
     message: string;
@@ -40,9 +42,10 @@ export declare function gitRefExists(projectPath: string, ref: string): Promise<
  * 相对基线 ref 的工作树差异 numstat：
  * - 若当前 HEAD === baseline.head：`git diff baseline.head`（含 staged+unstaged）
  * - 若 agent 创建了新提交（HEAD 前移）：`git diff baseline.head..HEAD` 拿到已提交变更，再叠加工作树 diff
+ * excludeUnchangedPreDirty：基线前脏文件集合（按内容 hash 判定未变的应被排除，避免把用户原有改动归因给 agent，S3）。
  * 返回已跟踪文件相对基线的全部变更。
  */
-export declare function diffSinceBaseline(projectPath: string, baseRef: string | null): Promise<{
+export declare function diffSinceBaseline(projectPath: string, baseRef: string | null, excludeFiles?: ReadonlySet<string>): Promise<{
     numstat: NumstatRow[];
     changedLinesPerFile: Map<string, string[]>;
 }>;

package/dist/verify/git-baseline.js

@@ -16,6 +16,7 @@ export async function captureBaseline(projectPath) {
             dirtyFiles: [],
             preExistingChanged: [],
             preExistingUntracked: [],
+            preDirtyHashes: {},
             preUntrackedHashes: {},
             capturedAt: new Date().toISOString(),
             message: "非 git 仓库：变更清单/diffstat 不可用（验收仍执行命令检查）。",
@@ -26,12 +27,20 @@ export async function captureBaseline(projectPath) {
     const statusRes = await gitOk(projectPath, ["status", "--porcelain", "--untracked-files=all"]);
     const porcelain = statusRes.ok ? statusRes.stdout.split("\n").filter((s) => s.trim().length > 0) : [];
     const parsed = parsePorcelain(porcelain);
+    // 记录全部预脏文件（已跟踪 staged/unstaged + 未跟踪）的内容 hash
+    const dirtyPaths = [...parsed.changed, ...parsed.untracked];
     const hashes = {};
-    for (const f of parsed.untracked) {
+    for (const f of dirtyPaths) {
         const h = await fileHash(path.join(projectPath, f));
         if (h)
             hashes[f] = h;
     }
+    const preUntrackedHashes = {};
+    for (const f of parsed.untracked) {
+        const h = await fileHash(path.join(projectPath, f));
+        if (h)
+            preUntrackedHashes[f] = h;
+    }
     return {
         isRepo: true,
         head,
@@ -39,7 +48,8 @@ export async function captureBaseline(projectPath) {
         dirtyFiles: porcelain,
         preExistingChanged: parsed.changed,
         preExistingUntracked: parsed.untracked,
-        preUntrackedHashes: hashes,
+        preDirtyHashes: hashes,
+        preUntrackedHashes,
         capturedAt: new Date().toISOString(),
         message: head
             ? `基线 HEAD=${head}，工作树${porcelain.length > 0 ? `脏（${porcelain.length} 项）` : "干净"}。`
@@ -117,14 +127,20 @@ export async function gitRefExists(projectPath, ref) {
  * 相对基线 ref 的工作树差异 numstat：
  * - 若当前 HEAD === baseline.head：`git diff baseline.head`（含 staged+unstaged）
  * - 若 agent 创建了新提交（HEAD 前移）：`git diff baseline.head..HEAD` 拿到已提交变更，再叠加工作树 diff
+ * excludeUnchangedPreDirty：基线前脏文件集合（按内容 hash 判定未变的应被排除，避免把用户原有改动归因给 agent，S3）。
  * 返回已跟踪文件相对基线的全部变更。
  */
-export async function diffSinceBaseline(projectPath, baseRef) {
+export async function diffSinceBaseline(projectPath, baseRef, excludeFiles) {
+    const skip = (f) => (excludeFiles ? excludeFiles.has(f) : false);
     if (!baseRef || !(await gitRefExists(projectPath, baseRef))) {
         // 基线 ref 无效/缺失：退回当前 HEAD（仅跟踪工作树 + 已提交到 HEAD 的变化）
-        const n = await gitNumstat(projectPath, "HEAD");
-        const lines = await gitChangedLines(projectPath, "HEAD");
-        return { numstat: n, changedLinesPerFile: lines };
+        const allN = await gitNumstat(projectPath, "HEAD");
+        const n = allN.filter((r) => !skip(r.file));
+        const allLines = await gitChangedLines(projectPath, "HEAD");
+        for (const f of [...allLines.keys()])
+            if (skip(f))
+                allLines.delete(f);
+        return { numstat: n, changedLinesPerFile: allLines };
     }
     const headNow = (await gitOk(projectPath, ["rev-parse", "HEAD"])).stdout.trim();
     // 工作树中相对基线的变更 = (baseline→工作树)，含 commit 前移部分
@@ -134,9 +150,13 @@ export async function diffSinceBaseline(projectPath, baseRef) {
     const worktree = parseNumstat(w.stdout);
     const byFile = new Map();
     for (const row of committed) {
+        if (skip(row.file))
+            continue;
         byFile.set(row.file, { ...row });
     }
     for (const row of worktree) {
+        if (skip(row.file))
+            continue;
         const prev = byFile.get(row.file);
         if (prev) {
             // 合并：同文件在基线→HEAD 与 HEAD→工作树都有改动
@@ -161,7 +181,7 @@ export async function diffSinceBaseline(projectPath, baseRef) {
                 cur = fh[1] ?? null;
                 continue;
             }
-            if (line.startsWith("+") && !line.startsWith("+++") && cur) {
+            if (line.startsWith("+") && !line.startsWith("+++") && cur && !skip(cur)) {
                 const arr = toMap.get(cur) ?? [];
                 arr.push(line.slice(1));
                 toMap.set(cur, arr);

package/dist/verify/report.js

@@ -20,7 +20,7 @@ export function reportToMd(report) {
     L.push(`- 项目: ${report.projectPath}`);
     L.push(`- 开始: ${report.startedAt}`);
     L.push(`- 结束: ${report.finishedAt}`);
-    L.push(`- 结论: **${report.verdict === "passed" ? "通过 ✅" : "失败 ❌"}**`);
+    L.push(`- 结论: **[${report.verdict === "passed" ? "PASS" : "FAIL"}]**`);
     L.push("", "## 自动命令检查", "");
     if (report.checks.length === 0)
         L.push("（无可运行的检查项）", "");
@@ -29,7 +29,7 @@ export function reportToMd(report) {
         L.push(`- [${mark}] ${c.name} — \`${c.cmd}\`${c.durationMs >= 0 ? ` (${c.durationMs}ms)` : ""}${c.skipped && c.reason ? ` — ${c.reason}` : ""}`);
         if (!c.passed && !c.skipped) {
             if (c.timeout)
-                L.push(`  - ⚠️ 超时（${c.durationMs}ms）`);
+                L.push(`  - [WARN] 超时（${c.durationMs}ms）`);
             L.push(`  - 退出码: ${c.exitCode ?? "n/a"}`);
             if (c.outputTail) {
                 L.push("  - 输出尾部:", "", "    ```");
@@ -68,12 +68,12 @@ export function reportToMd(report) {
         if (sig.secretLike)
             L.push(`- 疑似密钥/令牌形态 ${sig.secretLike} 处`);
         for (const f of a.bigFileChanges)
-            L.push(`- ⚠️ 超大单文件改动: ${f}`);
+            L.push(`- [WARN] 超大单文件改动: ${f}`);
         for (const w of a.warnings)
-            L.push(`- ⚠️ ${w}`);
+            L.push(`- [WARN] ${w}`);
     }
     for (const n of a.notes)
-        L.push(`- 💡 ${n}`);
+        L.push(`- [INFO] ${n}`);
     L.push("", "---", "", report.message, "");
     return L.join("\n");
 }
@@ -83,8 +83,8 @@ export function summarizeReport(report) {
     const fail = report.checks.filter((c) => !c.passed && !c.skipped);
     const skip = report.checks.filter((c) => c.skipped).length;
     const head = report.passed
-        ? `✅ 验收通过（第 ${report.round} 轮）：${passCount}/${report.checks.length} 项命令检查通过${skip ? `，${skip} 项跳过` : ""}。`
-        : `❌ 验收失败（第 ${report.round} 轮）：${fail.length} 项检查未通过${skip ? `，${skip} 项跳过` : ""}。`;
+        ? `[PASS] 验收通过（第 ${report.round} 轮）：${passCount}/${report.checks.length} 项命令检查通过${skip ? `，${skip} 项跳过` : ""}。`
+        : `[FAIL] 验收失败（第 ${report.round} 轮）：${fail.length} 项检查未通过${skip ? `，${skip} 项跳过` : ""}。`;
     const lines = [head, ""];
     for (const c of report.checks) {
         const st = c.skipped ? "SKIP" : c.passed ? "PASS" : "FAIL";

package/dist/version.generated.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 版本单一来源（S4）：由 build 前的脚本从 package.json 注入。
+ * 若直接源码运行（未注入），回退读 package.json；再失败给占位。
+ * 本文件由 scripts/sync-version.mjs 在每次 build 前重新生成。
+ */
+export declare const MCP_SERVER_VERSION = "0.1.3";

package/dist/version.generated.js

@@ -0,0 +1,7 @@
+/**
+ * 版本单一来源（S4）：由 build 前的脚本从 package.json 注入。
+ * 若直接源码运行（未注入），回退读 package.json；再失败给占位。
+ * 本文件由 scripts/sync-version.mjs 在每次 build 前重新生成。
+ */
+// generated: 勿手改 —— 运行 `npm run build` 自动同步
+export const MCP_SERVER_VERSION = "0.1.3";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tianshu-mcp",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "天枢 × AI-Agent 编排 MCP server —— 由天枢调度本 server 去驱动外部 AI-Agent CLI（Codex/Zcode/TraeWork）完成 项目开发 → 验收 → 失败返修 → 再验收 的闭环。",
   "type": "module",
   "license": "MIT",
@@ -22,7 +22,8 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "sync-version": "node scripts/sync-version.mjs",
+    "build": "npm run sync-version && tsc -p tsconfig.build.json",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
     "test": "vitest run",
@@ -47,7 +48,8 @@
     "prettier": "^3.4.2",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vite": "^6.4.3",
+    "vitest": "^3.2.7"
   },
   "keywords": [
     "mcp",