agentflowctl 0.13.1 → 0.14.0

package/dist/insights.js

@@ -0,0 +1,85 @@
+import { RetryCategories } from "./store.js";
+export const RETRY_LABEL = {
+    agent_error: "Agent 執行失敗",
+    missing_artifact: "缺少必要檔案",
+    format_invalid: "輸出格式錯誤",
+    handoff_invalid: "交接回覆不合格",
+    open_handoff: "未結交接事項",
+    review_changes: "審查要求修改",
+    arbitration_revise: "仲裁要求修訂",
+    plan_tampered: "改動已鎖定的計畫檔",
+    tests_not_written: "未寫測試",
+    tests_not_red: "紅燈測試未失敗",
+    tests_modified: "實作改了測試",
+    tests_not_green: "測試仍未通過",
+    tests_deleted: "刪除測試檔",
+    checks_failed: "專案檢查失敗",
+};
+export const FAILURE_LABEL = {
+    retry_limit: "關卡重試達上限",
+    arbitration_stop: "仲裁停止",
+    open_handoff: "PR 前仍有未結事項",
+    agent_budget: "agent 次數用完",
+    error: "執行時發生錯誤",
+    cancelled: "使用者取消",
+    unknown: "未分類（舊 run）",
+};
+/** 讀到較新版本寫入、這一版不認得的分類時，直接顯示代碼 */
+export function retryLabel(category) {
+    return RETRY_LABEL[category] ?? category;
+}
+export function failureLabel(category) {
+    return FAILURE_LABEL[(category ?? "unknown")] ?? category;
+}
+const TASK_PHASES = ["tests", "code", "review", "review-run", "verify", "fix"];
+/** 任務關卡的 key 帶有 task id（T1:tests），跨 run 彙總時合併成同一種關卡 */
+export function gateOf(key) {
+    const i = key.lastIndexOf(":");
+    if (i < 0)
+        return key;
+    const phase = key.slice(i + 1);
+    return TASK_PHASES.includes(phase) ? `任務:${phase}` : key;
+}
+const OUTCOMES = ["done", "failed", "paused", "awaiting_approval"];
+export function outcomeOf(stage) {
+    return OUTCOMES.includes(stage) ? stage : "active";
+}
+const countDesc = (a, b) => b.count - a.count;
+export function computeInsights(runs) {
+    const byOutcome = { done: 0, failed: 0, paused: 0, awaiting_approval: 0, active: 0 };
+    const failures = new Map();
+    const cat = new Map();
+    const gates = new Map();
+    for (const run of runs) {
+        const outcome = outcomeOf(run.stage);
+        byOutcome[outcome] += 1;
+        if (outcome === "failed") {
+            const f = run.failureCategory ?? "unknown";
+            failures.set(f, (failures.get(f) ?? 0) + 1);
+        }
+        for (const r of run.retries) {
+            const cur = cat.get(r.category) ?? { count: 0, finals: 0 };
+            cur.count += 1;
+            if (r.final)
+                cur.finals += 1;
+            cat.set(r.category, cur);
+            const gate = gateOf(r.key);
+            gates.set(gate, (gates.get(gate) ?? 0) + 1);
+        }
+    }
+    const topOf = (retries) => {
+        const n = new Map();
+        for (const r of retries)
+            n.set(r.category, (n.get(r.category) ?? 0) + 1);
+        return [...n.entries()].sort((a, b) => b[1] - a[1] || RetryCategories.indexOf(a[0]) - RetryCategories.indexOf(b[0]))[0]?.[0];
+    };
+    return {
+        runCount: runs.length,
+        byOutcome,
+        byFailure: [...failures.entries()].map(([category, count]) => ({ category, count })).sort(countDesc),
+        byCategory: [...cat.entries()].map(([category, v]) => ({ category, ...v })).sort(countDesc),
+        byGate: [...gates.entries()].map(([gate, count]) => ({ gate, count })).sort(countDesc),
+        runs: runs.map((r) => ({ id: r.id, stage: r.stage, retries: r.retries.length, topCategory: topOf(r.retries) })),
+    };
+}
+//# sourceMappingURL=insights.js.map

package/dist/modelSelection.js

@@ -8,27 +8,35 @@ export function effectiveStageStrengths(cfg) {
     const custom = cfg.modelSelection.stageStrength;
     return Object.fromEntries(Object.keys(DEFAULT_STAGE_STRENGTH).map((stage) => [stage, { strength: custom[stage] ?? DEFAULT_STAGE_STRENGTH[stage], custom: custom[stage] !== undefined }]));
 }
+/**
+ * 審查失敗計數的鍵。scope 是任務群 id：一群失敗只讓同一群的下一次審查升級，不牽動同一輪的其他群。
+ * 鍵一律以步驟名稱開頭，clearModelReviewStage 才能用前綴一次清掉。
+ */
+function reviewFailureKey(step, reviewer, scope) {
+    return scope ? `${step}:${scope}:${reviewer}` : `${step}:${reviewer}`;
+}
 /** 小組審查失敗只影響該審查者的下一次選模。 */
-export function recordModelReviewFailure(run, step, reviewer) {
-    const key = `${step}:${reviewer}`;
+export function recordModelReviewFailure(run, step, reviewer, scope) {
+    const key = reviewFailureKey(step, reviewer, scope);
     return { ...run, modelRetryAttempts: { ...run.modelRetryAttempts, [key]: (run.modelRetryAttempts?.[key] ?? 0) + 1 } };
 }
-export function clearModelReviewFailure(run, step, reviewer) {
+export function clearModelReviewFailure(run, step, reviewer, scope) {
     const attempts = { ...run.modelRetryAttempts };
-    delete attempts[`${step}:${reviewer}`];
+    delete attempts[reviewFailureKey(step, reviewer, scope)];
     return { ...run, modelRetryAttempts: attempts };
 }
 export function clearModelReviewStage(run, step) {
-    const attempts = Object.fromEntries(Object.entries(run.modelRetryAttempts ?? {}).filter(([key]) => !key.startsWith(`${step}:`)));
+    const prefixes = step === "plan-review" ? ["plan-review:", "plan-review-group:"] : ["review:"];
+    const attempts = Object.fromEntries(Object.entries(run.modelRetryAttempts ?? {}).filter(([key]) => !prefixes.some((prefix) => key.startsWith(prefix))));
     return { ...run, modelRetryAttempts: attempts };
 }
-/** 把步驟名稱（例如 `T-1-code`、`plan-review`）對應到階段鍵；不認得時回傳 undefined。 */
+/** 把步驟名稱（例如 `T-1-code`、`plan-review`、`plan-review-group`）對應到階段鍵；不認得時回傳 undefined。 */
 export function stageOfStep(step) {
     const task = /^T-\d+-(tests|code|review|fix)$/.exec(step);
     if (task)
         return { tests: "taskTests", code: "taskCode", review: "taskReview", fix: "taskFix" }[task[1]];
     const stage = {
-        spec: "spec", plan: "plan", "plan-review": "planReview", "plan-fix": "planFix",
+        spec: "spec", plan: "plan", "plan-review": "planReview", "plan-review-group": "planReview", "plan-fix": "planFix",
         "plan-arbiter": "planArbiter", fix: "fix", review: "review",
     };
     return stage[step];
@@ -39,10 +47,10 @@ function stepStage(step) {
         throw new Error(`未知的 LLM 步驟：${step}`);
     return found;
 }
-function escalation(run, stage, step, reviewer) {
+function escalation(run, stage, step, reviewer, scope) {
     const a = run.attempts;
     if (stage === "planReview" || stage === "review")
-        return run.modelRetryAttempts?.[`${step}:${reviewer ?? ""}`] ?? 0;
+        return run.modelRetryAttempts?.[reviewFailureKey(step, reviewer ?? "", scope)] ?? 0;
     if (stage === "planArbiter")
         return 0;
     if (stage === "planFix")
@@ -61,7 +69,7 @@ function escalation(run, stage, step, reviewer) {
     return a[step] ?? 0;
 }
 /** 每次呼叫前依目前設定與 run 狀態選擇模型；不修改任何狀態。 */
-export function selectModel(run, cfg, agent, step, complexity, reviewer) {
+export function selectModel(run, cfg, agent, step, complexity, reviewer, scope) {
     const def = cfg.agents[agent];
     if (!def)
         throw new Error(`未定義的 agent：${agent}`);
@@ -75,7 +83,7 @@ export function selectModel(run, cfg, agent, step, complexity, reviewer) {
     const stage = stepStage(step);
     const floor = effectiveStageStrengths(cfg)[stage].strength;
     const baseline = stage.startsWith("task") ? Math.max(LEVEL[floor], LEVEL[complexity ?? "medium"]) : LEVEL[floor];
-    const targetStrength = STRENGTHS[Math.min(2, baseline + escalation(run, stage, step, reviewer))];
+    const targetStrength = STRENGTHS[Math.min(2, baseline + escalation(run, stage, step, reviewer, scope))];
     const candidates = def.models.filter((m) => LEVEL[m.strength] >= LEVEL[targetStrength]);
     const min = Math.min(...candidates.map((m) => LEVEL[m.strength]));
     const chosen = candidates.find((m) => LEVEL[m.strength] === min)

package/dist/paths.js

@@ -18,6 +18,10 @@ export const runsDir = () => join(agentflowctlDir(), "runs");
 export const runDir = (id) => join(runsDir(), id);
 export const logDir = (id) => join(runDir(id), "logs");
 export const handoffPath = (id) => join(runDir(id), "handoff.json");
+/** 分層計畫審查的結果與本輪進度：是關卡輸入，放在 worktree 外，agent 改不到 */
+export const planReviewStatePath = (id) => join(runDir(id), "plan-review-state.json");
+/** 已交付仲裁、尚未得出裁決：暫停後 resume 直接回到仲裁。放在 worktree 外，agent 無法偽造 */
+export const planArbitrationPath = (id) => join(runDir(id), "plan-arbitration.json");
 /** 每個 run 一個 git worktree，Agent 只在這裡工作，不碰你正在編輯的檔案 */
 export const worktreesDir = () => join(agentflowctlDir(), "worktrees");
 export const worktreeDir = (id) => join(worktreesDir(), id);

package/dist/planReview.js

@@ -0,0 +1,333 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+// 前面不能緊接路徑字元，中文標點與中文字後面的路徑才抓得到，URL 片段則不會被當成路徑
+const FILE_TOKEN = /(?<![A-Za-z0-9_.@/-])((?:[A-Za-z0-9_.@-]+\/)+[A-Za-z0-9_.@-]+\.[A-Za-z0-9]+)/g;
+const TASK_HEADING = /^(#{2,6}) (T-\d+)(?!\d)/;
+const OVERVIEW_MAX_LINES = 120;
+const EVIDENCE_MAX_LINES = 40;
+const Verdict = z.enum(["approve", "changes_requested"]);
+const ReviewedTask = z.object({
+    fingerprint: z.string(),
+    acceptance: z.array(z.string()),
+    dependsOn: z.array(z.string()),
+    verdict: Verdict,
+});
+export const PlanReviewed = z.object({
+    overview: z.string(),
+    tasks: z.record(z.string(), ReviewedTask),
+});
+export const PlanReviewCall = z.object({
+    key: z.string(),
+    reviewer: z.string(),
+    verdict: Verdict,
+    issueLines: z.array(z.string()),
+    taskIds: z.array(z.string()).optional(),
+});
+export const PlanReviewRound = z.object({
+    round: z.number().int(),
+    planKey: z.string(),
+    calls: z.array(PlanReviewCall),
+});
+/** reviewed 是上一次整輪完成的結果；round 是本輪進行中已成功的呼叫 */
+export const PlanReviewState = z.object({
+    version: z.literal(1),
+    reviewed: PlanReviewed.optional(),
+    round: PlanReviewRound.optional(),
+});
+/** 已交付仲裁、尚未得出裁決的紀錄；planKey 對不上表示計畫在暫停期間改過 */
+export const PendingArbitration = z.object({
+    planReviewer: z.string(),
+    planKey: z.string(),
+});
+function taskNum(id) {
+    return Number(id.slice(2));
+}
+/** 從任務描述抽出含目錄的檔案路徑（略過 .flow/），排序後去重 */
+export function extractFiles(description) {
+    const found = new Set();
+    for (const match of description.matchAll(FILE_TOKEN)) {
+        const path = match[1];
+        if (!path || path.startsWith(".flow/"))
+            continue;
+        found.add(path);
+    }
+    return [...found].sort();
+}
+function toGroup(members, index) {
+    return {
+        id: `G-${index + 1}`,
+        taskIds: members.map((task) => task.id).sort((a, b) => taskNum(a) - taskNum(b)),
+        files: [...new Set(members.flatMap((task) => extractFiles(task.description)))].sort(),
+    };
+}
+/** 依共用路徑把任務併成自然群，抽不到路徑的依附相依目標或併成一群 */
+export function taskClusters(tasks) {
+    const parent = new Map(tasks.map((task) => [task.id, task.id]));
+    const find = (id) => {
+        const next = parent.get(id) ?? id;
+        if (next === id)
+            return id;
+        const root = find(next);
+        parent.set(id, root);
+        return root;
+    };
+    const unite = (a, b) => {
+        const ra = find(a);
+        const rb = find(b);
+        if (ra !== rb)
+            parent.set(rb, ra);
+    };
+    const filesOf = new Map(tasks.map((task) => [task.id, extractFiles(task.description)]));
+    const hasFiles = (id) => (filesOf.get(id) ?? []).length > 0;
+    const owners = new Map();
+    for (const task of tasks) {
+        for (const file of filesOf.get(task.id) ?? []) {
+            const owner = owners.get(file);
+            if (owner)
+                unite(owner, task.id);
+            else
+                owners.set(file, task.id);
+        }
+    }
+    for (const task of tasks) {
+        if (hasFiles(task.id))
+            continue;
+        // 只併入 dependsOn 順序中第一個抽得到路徑的目標，避免同時依附多個群時把它們合併起來
+        for (const dep of task.dependsOn) {
+            if (hasFiles(dep)) {
+                unite(dep, task.id);
+                break;
+            }
+        }
+    }
+    // 沒依附到路徑的檔名任務併成同一群，避免每個都自成一群、每輪多出一次呼叫
+    const loose = tasks.filter((task) => !hasFiles(task.id) && find(task.id) === task.id);
+    for (const task of loose.slice(1))
+        unite(loose[0].id, task.id);
+    const buckets = new Map();
+    for (const task of tasks) {
+        const root = find(task.id);
+        buckets.set(root, [...(buckets.get(root) ?? []), task]);
+    }
+    return [...buckets.values()]
+        .map((members) => ({ members, order: Math.min(...members.map((task) => taskNum(task.id))) }))
+        .sort((a, b) => a.order - b.order)
+        .map((cluster, index) => toGroup(cluster.members, index));
+}
+/** 自然群超過上限時把相鄰的群合併，得到本輪要審的任務群 */
+export function planReviewGroups(tasks, opts) {
+    const clusters = taskClusters(tasks);
+    // 群數不超過上限，也不讓每群平均少於 tasksPerGroup 個任務，避免拆出很多只有一兩個任務的呼叫
+    const limit = Math.max(1, Math.min(opts.maxGroups, Math.floor(tasks.length / opts.tasksPerGroup)));
+    if (clusters.length <= limit)
+        return clusters;
+    const packed = [];
+    clusters.forEach((cluster, index) => {
+        const slot = Math.floor((index * limit) / clusters.length);
+        packed[slot] = [...(packed[slot] ?? []), ...cluster.taskIds];
+    });
+    return packed.map((ids, index) => toGroup(tasks.filter((task) => ids.includes(task.id)), index));
+}
+/** plan.md 缺少「## T-<數字>」標題的任務 id */
+export function missingTaskHeadings(planMd, taskIds) {
+    const found = new Set(planMd.split("\n").flatMap((line) => {
+        const match = TASK_HEADING.exec(line);
+        return match ? [match[2]] : [];
+    }));
+    return taskIds.filter((id) => !found.has(id));
+}
+/** 判斷是否走分層審查；不走時附上第一個不成立的原因 */
+export function layeredReview(tasks, planMd, opts) {
+    if (!opts.enabled || tasks.length < opts.minTasks)
+        return { layered: false };
+    const clusters = taskClusters(tasks);
+    if (clusters.length < 2)
+        return { layered: false, reason: "任務要改的檔案互相重疊，只能分成一群" };
+    const largest = Math.max(...clusters.map((cluster) => cluster.taskIds.length));
+    // 一群占了大半時，分層只是多一次索引呼叫，也最容易漏掉那一群內部的問題
+    if (largest * 3 > tasks.length * 2) {
+        return { layered: false, reason: `最大的一群有 ${largest} 個任務，超過總數 ${tasks.length} 的三分之二` };
+    }
+    const groups = planReviewGroups(tasks, opts);
+    if (groups.length < 2)
+        return { layered: false, reason: `任務數 ${tasks.length} 不足以讓每群平均至少 ${opts.tasksPerGroup} 個` };
+    // 沒有任務標題就切不出難度證據，群審查者會缺資料
+    const missing = missingTaskHeadings(planMd, tasks.map((task) => task.id));
+    if (missing.length)
+        return { layered: false, reason: `plan.md 缺少 ${missing.join(", ")} 的「## T-<數字>」標題` };
+    return { layered: true, groups };
+}
+/** 索引審查用的任務清單：每個任務一行摘要加一行描述 */
+export function planReviewIndex(tasks) {
+    return tasks.map((task) => {
+        const deps = task.dependsOn.length ? task.dependsOn.join(", ") : "（無）";
+        const description = task.description.trim().replace(/\s*\n\s*/g, " ");
+        return `- ${task.id} ${task.title} | ${task.acceptance.join(", ")} | depends：${deps}\n  ${description}`;
+    }).join("\n");
+}
+/** 不在群內、但與群內任務直接相依的任務，依 tasks.json 順序 */
+export function neighborTasks(tasks, taskIds) {
+    const inGroup = new Set(taskIds);
+    const linked = new Set();
+    for (const task of tasks) {
+        if (inGroup.has(task.id))
+            for (const dep of task.dependsOn)
+                linked.add(dep);
+        else if (task.dependsOn.some((dep) => inGroup.has(dep)))
+            linked.add(task.id);
+    }
+    return tasks.filter((task) => linked.has(task.id) && !inGroup.has(task.id));
+}
+/** 群內有 high 任務時由 quorum 位審查，否則一位 */
+export function groupReviewerCount(groupTasks, quorum) {
+    return groupTasks.some((task) => task.complexity === "high") ? quorum : 1;
+}
+/** 任務指紋：任務內容、對應驗收條文與難度證據，任一變了就要重審 */
+export function taskFingerprint(task, acceptance, planMd) {
+    const byId = new Map(acceptance.map((item) => [item.id, item.description]));
+    return JSON.stringify({
+        id: task.id,
+        title: task.title,
+        description: task.description,
+        complexity: task.complexity ?? null,
+        dependsOn: task.dependsOn,
+        acceptance: task.acceptance.map((id) => ({ id, description: byId.get(id) ?? "" })),
+        evidence: extractPlanEvidence(planMd, [task.id]),
+    });
+}
+/** 整體做法的指紋 */
+export function overviewKey(planMd) {
+    return planContentKey([planOverview(planMd)]);
+}
+/** 解析審查狀態；壞掉或格式不符時回傳 undefined，當成沒有前次結果 */
+export function readPlanReviewState(raw) {
+    try {
+        const parsed = PlanReviewState.safeParse(JSON.parse(raw));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 解析仲裁待完成紀錄；壞掉或格式不符時回傳 undefined */
+export function readPendingArbitration(raw) {
+    try {
+        const parsed = PendingArbitration.safeParse(JSON.parse(raw));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 整輪完成後的新審查結果：審到的任務寫上群的 verdict，沒審到的沿用前次 */
+export function applyReviewVerdicts(prev, tasks, acceptance, planMd, groupVerdicts) {
+    const verdictOf = new Map();
+    for (const group of groupVerdicts) {
+        for (const id of group.taskIds) {
+            // 同一群有多位審查者時，任一位要求修改就算要求修改
+            if (verdictOf.get(id) !== "changes_requested")
+                verdictOf.set(id, group.verdict);
+        }
+    }
+    const tasksState = {};
+    for (const task of tasks) {
+        const verdict = verdictOf.get(task.id) ?? prev?.tasks[task.id]?.verdict;
+        if (!verdict)
+            continue;
+        tasksState[task.id] = {
+            fingerprint: taskFingerprint(task, acceptance, planMd),
+            acceptance: task.acceptance,
+            dependsOn: task.dependsOn,
+            verdict,
+        };
+    }
+    return { overview: overviewKey(planMd), tasks: tasksState };
+}
+function sameList(a, b) {
+    return a.join("\0") === b.join("\0");
+}
+/** 這輪要重審的任務 id，依 tasks.json 順序 */
+export function dirtyTaskIds(prev, tasks, acceptance, planMd) {
+    // 整體做法是每一群核准的前提，一變就全部重審
+    if (!prev || prev.overview !== overviewKey(planMd))
+        return tasks.map((task) => task.id);
+    const dirty = new Set();
+    for (const task of tasks) {
+        const prior = prev.tasks[task.id];
+        if (!prior || prior.verdict !== "approve" || prior.fingerprint !== taskFingerprint(task, acceptance, planMd))
+            dirty.add(task.id);
+    }
+    for (const task of tasks) {
+        const prior = prev.tasks[task.id];
+        if (!prior)
+            continue;
+        if (sameList(prior.acceptance, task.acceptance) && sameList(prior.dependsOn, task.dependsOn))
+            continue;
+        dirty.add(task.id);
+        for (const id of new Set([...prior.dependsOn, ...task.dependsOn]))
+            dirty.add(id);
+        for (const other of tasks) {
+            if (other.dependsOn.includes(task.id))
+                dirty.add(other.id);
+        }
+    }
+    return tasks.map((task) => task.id).filter((id) => dirty.has(id));
+}
+/** 含任一髒任務的群 */
+export function dirtyGroups(groups, dirtyIds) {
+    const dirty = new Set(dirtyIds);
+    return groups.filter((group) => group.taskIds.some((id) => dirty.has(id)));
+}
+/** plan.md 第一個任務標題之前的整體做法，最多 OVERVIEW_MAX_LINES 行 */
+export function planOverview(planMd) {
+    const lines = planMd.split("\n");
+    const end = lines.findIndex((line) => TASK_HEADING.test(line));
+    // trim：任務標題前的空行只是排版，不 trim 的話多一行、少一行空白都會改變整體做法指紋，讓所有群重審
+    return (end === -1 ? lines : lines.slice(0, end)).slice(0, OVERVIEW_MAX_LINES).join("\n").trim();
+}
+/** 各任務標題下的難度摘錄，依傳入的 id 順序接起來 */
+export function extractPlanEvidence(planMd, taskIds) {
+    const wanted = new Set(taskIds);
+    const byId = new Map();
+    let current = null;
+    for (const line of planMd.split("\n")) {
+        const heading = /^(#{1,6}) /.exec(line);
+        const task = TASK_HEADING.exec(line);
+        if (task)
+            current = { id: task[2], level: task[1].length };
+        else if (heading && current && heading[1].length <= current.level)
+            current = null;
+        if (current && wanted.has(current.id))
+            byId.set(current.id, [...(byId.get(current.id) ?? []), line]);
+    }
+    return taskIds
+        .filter((id) => byId.has(id))
+        .map((id) => byId.get(id).slice(0, EVIDENCE_MAX_LINES).join("\n").trimEnd())
+        .join("\n\n");
+}
+/** 審查回應中標題剛好是這些任務 id 的節 */
+export function repliesForTasks(replies, taskIds) {
+    if (!replies.trim())
+        return "";
+    const chunks = replies.split(/(?=^## )/m);
+    return chunks.filter((chunk) => {
+        const title = chunk.split("\n")[0] ?? "";
+        return taskIds.some((id) => new RegExp(`^## ${id}(?!\\d)`).test(title));
+    }).join("").trim();
+}
+/** 未通過意見排序後的文字，用來偵測僵持 */
+export function reviewFingerprint(issueLines) {
+    return [...issueLines].sort().join("\n");
+}
+/** 多段文字以 \0 串接後的 sha256 */
+export function planContentKey(texts) {
+    return createHash("sha256").update(texts.join("\0")).digest("hex");
+}
+/** 輪次與計畫雜湊都對得上時才沿用本輪進度 */
+export function roundProgress(state, round, planKey) {
+    const progress = state?.round;
+    if (!progress || progress.round !== round || progress.planKey !== planKey)
+        return undefined;
+    return progress;
+}
+//# sourceMappingURL=planReview.js.map

package/dist/schemas.js

@@ -141,6 +141,16 @@ export const RepoConfig = z.object({
     planReviewQuorum: z.number().int().min(1).default(1),
     /** 計畫審查僵持不下（達到重試上限或意見不再變化）時，交給第三方 agent 仲裁，而不是停下來等人 */
     planArbiter: z.boolean().default(true),
+    /** 任務夠多、能依檔案分群時，計畫審查改成每輪一次索引加上只審有變動的任務群 */
+    planReviewLayers: z.strictObject({
+        enabled: z.boolean().default(true),
+        /** 任務數達到這個值才考慮分層 */
+        minTasks: z.number().int().min(2).default(7),
+        /** 每輪最多幾群 */
+        maxGroups: z.number().int().min(2).default(5),
+        /** 群數也不超過任務數除以這個值，避免拆出很多只有一兩個任務的呼叫 */
+        tasksPerGroup: z.number().int().min(1).default(3),
+    }).default({ enabled: true, minTasks: 7, maxGroups: 5, tasksPerGroup: 3 }),
     /**
      * 仲裁意見分歧時怎麼辦（只有兩家時由雙方各自仲裁，才可能分歧）：
      * proceed＝繼續實作，爭議記錄在計畫裡，後面還有測試、驗證與程式碼審查把關；stop＝停下來等人
@@ -160,6 +170,8 @@ export const RepoConfig = z.object({
         { name: "build", cmd: "npx vite build" },
     ]),
 });
+/** 讓 run 進入 failed 的原因：關卡重試達上限以外，還有仲裁停止、PR 前仍有未結事項、agent 次數用完、例外與使用者取消 */
+export const FailureCategory = z.enum(["retry_limit", "arbitration_stop", "open_handoff", "agent_budget", "error", "cancelled"]);
 export const FlowRun = z.object({
     id: z.string(),
     baseBranch: z.string(),
@@ -198,6 +210,8 @@ export const FlowRun = z.object({
     lastTestsAuthor: z.string().optional(),
     failedStage: Stage.optional(),
     failureReason: z.string().optional(),
+    /** run 為什麼失敗，供 insights 跨 run 彙總；舊 run 沒有這個欄位 */
+    failureCategory: FailureCategory.optional(),
     prUrl: z.string().optional(),
     createdAt: z.string(),
     updatedAt: z.string(),

package/dist/stats.js

@@ -38,6 +38,32 @@ export function computeStats(entries) {
     const steps = [...byKey.values()].sort((a, b) => b.totalMs - a.totalMs);
     return { steps, agentMs, cmdMs, wallMs: last > first ? last - first : 0, unfinished };
 }
+/** task id 只在同一個 run 內有意義；跨 run 合併時 T-1-green、T-3-green 都算「任務:green」 */
+export const stepKind = (step) => step.replace(/^T-\d+-/, "任務:");
+export function mergeStats(runs) {
+    const byKey = new Map();
+    let agentMs = 0;
+    let cmdMs = 0;
+    let unfinished = 0;
+    for (const run of runs) {
+        agentMs += run.agentMs;
+        cmdMs += run.cmdMs;
+        unfinished += run.unfinished;
+        for (const s of run.steps) {
+            const step = stepKind(s.step);
+            const key = `${s.kind}:${step}`;
+            const acc = byKey.get(key) ?? { step, kind: s.kind, runs: 0, failed: 0, unfinished: 0, totalMs: 0, maxMs: 0 };
+            acc.runs += s.runs;
+            acc.failed += s.failed;
+            acc.unfinished += s.unfinished;
+            acc.totalMs += s.totalMs;
+            acc.maxMs = Math.max(acc.maxMs, s.maxMs);
+            byKey.set(key, acc);
+        }
+    }
+    const steps = [...byKey.values()].sort((a, b) => b.failed - a.failed || b.runs - a.runs || b.totalMs - a.totalMs);
+    return { steps, agentMs, cmdMs, unfinished };
+}
 /** 毫秒轉成 1h02m、3m05s、12s */
 export function formatDuration(ms) {
     const sec = Math.round(ms / 1000);