const branch = sh('git rev-parse --abbrev-ref HEAD') || '?';

const porcelain = sh('git status --porcelain').split('\n').filter(Boolean);

const dirty = porcelain.filter((l) => !l.startsWith('??'));

const untracked = porcelain.filter((l) => l.startsWith('??'));

let unpushed = 0;

const up = sh('git rev-list --count @{u}..HEAD'); if (/^\d+$/.test(up)) unpushed = +up;

const recent = sh('git log --oneline -6').split('\n').filter(Boolean)

.map((l) => l.replace(/^(\w+)\s/, '').slice(0, 64));

// 取脏文件路径(去掉前两列状态)，用于按模块归因

const dirtyPaths = dirty.map((l) => l.slice(3).trim()).filter(Boolean);

const untrackedPaths = untracked.map((l) => l.slice(3).trim()).filter(Boolean);

return { branch, dirtyCount: dirty.length, untrackedCount: untracked.length, unpushed, recent, dirtyPaths, untrackedPaths };

if (!runTests) return { ran: false, passing: null, failing: null, failingFiles: [] };

const outFile = '/tmp/cs-vitest.json';

try { sh(`npx vitest run src/web/client --reporter=json --outputFile=${outFile} 2>/dev/null`, 120000); } catch { /* */ }

try {

const j = JSON.parse(readFileSync(outFile, 'utf-8'));

const failingFiles = (j.testResults || []).filter((r) => r.status === 'failed')

.map((r) => r.name.replace(ROOT + '/', '')).filter(Boolean);

return { ran: true, passing: j.numPassedTests ?? null, failing: j.numFailedTests ?? null,

totalFiles: (j.testResults || []).length, failingFiles };

} catch { return { ran: true, passing: null, failing: null, failingFiles: [], error: 'parse failed' }; }

for (let i = Math.min(idx, lines.length - 1); i >= 0 && i > idx - 500; i--) {

const l = lines[i];

const m =

l.match(/^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s*(\w+)/) || // function foo

l.match(/^\s*(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[:=]/) || // const Foo = / : FC

l.match(/^\s*(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/) || // class Foo

l.match(/^\s*(?:export\s+)?(?:interface|type|enum)\s+(\w+)/) || // interface/type Foo

l.match(/^\s*(?:public\s+|private\s+|protected\s+|static\s+|async\s+|get\s+|set\s+)*(\w+)\s*\([^)]*\)\s*[:{]/); // 方法 foo() {

if (m && !SKIP_KW.has(m[1])) return m[1];

}

return null;

const out = sh(`git diff HEAD -U0 -- "${file}"`, 12000);

if (!out) return [];

let src = [];

try { src = readFileSync(path.join(ROOT, file), 'utf-8').split('\n'); } catch { return []; }

const funcs = new Set();

for (const line of out.split('\n')) {

const h = line.match(/^@@\s+-\d+(?:,\d+)?\s+\+(\d+)(?:,(\d+))?\s+@@/);

if (!h) continue;

const start = +h[1], count = h[2] === undefined ? 1 : +h[2];

for (let ln = start; ln < start + Math.max(count, 1); ln++) {

const name = enclosingDecl(src, ln - 1); // 行号 1-indexed → 数组 0-indexed

if (name) funcs.add(name);

}

}

return [...funcs].slice(0, 10);

const failing = tests.failingFiles || [];

const dirtyStatus = new Map(); // path -> 'M'|'A'|'D' (从 porcelain 第二列粗判)

for (const p of git.dirtyPaths) dirtyStatus.set(p, 'M');

for (const p of git.untrackedPaths || []) dirtyStatus.set(p, 'A');

return MODULES.map((m) => {

let files = 0;

const c = sh(`find ${m.prefix} -type f \\( -name '*.ts' -o -name '*.tsx' \\) 2>/dev/null | grep -v node_modules | wc -l`);

if (/^\d+$/.test(c)) files = +c;

// 该模块下「真源码」改动（滤掉垃圾噪音）→ 每个文件下钻到函数级。

const changedPaths = [...git.dirtyPaths, ...(git.untrackedPaths || [])]

.filter((p) => p.startsWith(m.prefix) && isSource(p));

const changes = changedPaths.slice(0, 12).map((p) => ({

file: p.slice(m.prefix.length).replace(/^\//, ''),

kind: dirtyStatus.get(p) === 'A' ? 'A' : 'M',

funcs: dirtyStatus.get(p) === 'A' ? [] : changedFuncs(p), // 新文件无 vs-HEAD diff，不列函数

}));

const dirty = changedPaths.length; // 源码改动数（不含垃圾，颗粒度对齐）

const brokenTests = failing.filter((p) => p.startsWith(m.prefix)).length;

const trust = brokenTests > 0 ? 'broken' : dirty > 0 ? 'claimed' : 'hard';

return { ...m, files, dirty, brokenTests, trust, changes };

}).filter((m) => m.files > 0);

const bpPath = path.join(ROOT, 'docs/spec/roadmap/blueprint.json');

if (!existsSync(bpPath)) return [];

let bp;

try { bp = JSON.parse(readFileSync(bpPath, 'utf-8')); } catch { return []; }

// 验证日志：verify-milestone 真跑 gate 绿后写的硬证据（id → {green, at, passing}）。

const vlogPath = path.join(ROOT, 'docs/spec/roadmap/.milestone-verified.json');

let vlog = {};

if (existsSync(vlogPath)) { try { vlog = JSON.parse(readFileSync(vlogPath, 'utf-8')); } catch { /* */ } }

const gateGreen = (id) => !!(vlog[id] && vlog[id].green === true);

// git 出货佐证（"feat(M15.a):"、"M8.c" 等引用数）——只做旁证，不当信任来源。

const log = sh('git log --oneline -600', 15000) || '';

const commitTally = {};

for (const m of log.matchAll(/\bM(\d+)(?:[.)\s:a-z]|$)/g)) { const k = 'M' + m[1]; commitTally[k] = (commitTally[k] || 0) + 1; }

return (bp.tasks || []).map((tk) => {

const subtasks = Array.isArray(tk.subtasks) ? tk.subtasks : [];

const done = subtasks.filter((s) => s.done).length;

const claim = tk.status; // 我声称的（done/wip/planned）——不当真

const deps = tk.dependsOn || [];

const green = gateGreen(tk.id);

const depsVerified = deps.every((d) => gateGreen(d)); // 依赖都 gate 验过了吗（断裂检测）

// ★信任裁决★：gate 绿+依赖验过=verified🟢；gate 绿但依赖没验=断裂(broken_seam)；

// 声称 done 但没跑 gate=claimed🟡(我嘴说的)；wip/planned 照声称。

let trust;

if (green && depsVerified) trust = 'verified';

else if (green && !depsVerified) trust = 'broken_seam';

else if (claim === 'done') trust = 'claimed';

else if (claim === 'wip') trust = 'wip';

else trust = 'planned';

// 下一个「可验证」= 声称 done、依赖都验过、自己还没跑 gate、且有 gate 可跑。

const actionable = claim === 'done' && !green && depsVerified && !!tk.verify;

return {

id: tk.id, num: +String(tk.id).replace(/\D/g, ''), title: tk.title,

status: claim, trust, actionable,

verifiedAt: vlog[tk.id] ? vlog[tk.id].at : null,

dependsOn: deps, depsVerified,

verify: tk.verify || null,

commits: commitTally[tk.id] || 0,

done, total: subtasks.length, subtasks,

};

}).sort((a, b) => a.num - b.num);

let forms = 4, target = 10, realDelivery = 0, paying = 0, mrr = 0;

const sp = path.join(ROOT, 'docs/spec/status.md');

if (existsSync(sp)) {

const t = readFileSync(sp, 'utf-8');

const m = t.match(/(\d+)\s*\/\s*(\d+)\s*种真实形态/); if (m) { forms = +m[1]; target = +m[2]; }

// 真 BOSS：「真人（非作者）成功交付（当前 **0**）」

const r = t.match(/成功交付（当前\s*\*{0,2}(\d+)/); if (r) realDelivery = +r[1];

// 终极 BOSS：「付费真人（当前 **0** · MRR **¥0**）」(分隔符容差，匹配到 ¥ 数字)

const p = t.match(/付费真人（当前\s*\*{0,2}(\d+)\*{0,2}[^¥]*¥?([\d.]+)/);

if (p) { paying = +p[1]; mrr = +p[2]; }

}

return { forms, target, realDelivery, users: 0, paying, mrr };