skyloom 1.13.6 → 1.13.7

package/src/core/agent.ts

@@ -28,6 +28,27 @@ import { LoopGuard } from './agent/guard';
 
 const log = getLogger('agent');
 
+/** Tools whose success means the filesystem changed (triggers the verify loop). */
+const WRITE_TOOL_RE = /^(write_|edit_|delete_|create_)|^run_bash$|^git_commit$/;
+
+/** Tools with side effects, hidden from the model while in plan mode. */
+const SIDE_EFFECT_TOOL_RE = /^(write_|edit_|delete_|create_|kill_|launch_|service_|browser_)|^run_bash$|^git_commit$|^open_path$|^delegate_to$/;
+
+/** Default context budget per recorded tool result (chars; ~3k tokens). */
+const TOOL_RESULT_LIMIT = 12000;
+
+/**
+ * Clamp an oversized tool result before it enters the context window:
+ * keep head + tail, tell the model what was cut and how to fetch precisely.
+ */
+export function clampToolResult(s: string, limit: number = TOOL_RESULT_LIMIT): string {
+  if (s.length <= limit) return s;
+  const head = s.slice(0, Math.floor(limit * 0.72));
+  const tail = s.slice(-Math.floor(limit * 0.18));
+  const cut = s.length - head.length - tail.length;
+  return `${head}\n…[工具结果过长，中间省略 ${cut} 字符 — 需要该部分时用更精确的参数重新调用（read_file 的 offset/limit、grep 定位、缩小查询范围）]\n${tail}`;
+}
+
 // Domain model lives in ./agent/task — re-exported here so importers of
 // '../core/agent' are unaffected by the Phase 3 split.
 import { AgentState, TaskState, Task, TaskResult } from './agent/task';
@@ -65,6 +86,11 @@ export class BaseAgent {
   protected _pendingRequests: Map<string, { resolve: (value: string) => void; reject: (err: Error) => void }> = new Map();
   protected _bgTasks: Set<Promise<void>> = new Set();
   approvalCallback: ((toolName: string, args: Record<string, any>) => Promise<boolean>) | null = null;
+  /** Plan mode: read-only tool set + plan-first instructions on each turn. */
+  planMode: boolean = false;
+  /** Set when this turn executed a tool that mutates the filesystem (verify trigger). */
+  protected _turnWroteFiles: boolean = false;
+  private _hooks: import('./hooks').Hooks | null = null;
   protected _turnLock: Promise<void> = Promise.resolve();
   private _turnLockCounter: number = 0;
   private _turnLockResolve: (() => void) | null = null;
@@ -145,10 +171,10 @@ export class BaseAgent {
     const lang = (this.config as any).llm?.language || 'zh';
     if (lang === 'en') {
       return prompt +
-        `\n\n## Thinking Protocol\nBefore acting, briefly weigh: (1) **What** is the actual need? (2) **How** sure am I? If <80%, flag with [uncertain] and ask.\nIf stuck, admit it — propose a partial answer or ask the user. Never fabricate.\n\n## Behavior\n- Act, don't narrate. No "I will..." before tool calls.\n- Stay in scope. Do what's asked, then stop.\n- Batch independent tool calls in one response.\n- Verify writes: read back, report verified state.\n- Call list_skills when the task needs specialized capabilities.`;
+        `\n\n## Thinking Protocol\nBefore acting, briefly weigh: (1) **What** is the actual need? (2) **How** sure am I? If <80%, flag with [uncertain] and ask.\nIf stuck, admit it — propose a partial answer or ask the user. Never fabricate.\n\n## Behavior\n- Act, don't narrate. No "I will..." before tool calls.\n- Stay in scope. Do what's asked, then stop.\n- Batch independent tool calls in one response.\n- For tasks with 3+ steps, plan with todo_write first and update item status as you go.\n- Verify writes: read back, report verified state.\n- Call list_skills when the task needs specialized capabilities.`;
     }
     return prompt +
-      `\n\n## 思考协议\n行动前快速判断：(1) 用户真实需求是什么？(2) 我有多大把握？低于80%标注 [不确定] 并主动询问。\n卡住时承认，给出部分答案或请求用户指导。绝不编造。\n\n## 行为守则\n- 直接行动,不预告。不说「我将要...」,直接调用工具\n- 不擅自扩大范围。用户要什么做什么,核心完成即止\n- 独立的工具调用一次发出,并行执行\n- 写入后回读验证,汇报已验证状态而非仅尝试\n- 任务涉及专业能力时（PPT/Excel/PDF/网页设计/代码审查等），先调 list_skills 查看可用技能，再用 use_skill 激活`;
+      `\n\n## 思考协议\n行动前快速判断：(1) 用户真实需求是什么？(2) 我有多大把握？低于80%标注 [不确定] 并主动询问。\n卡住时承认，给出部分答案或请求用户指导。绝不编造。\n\n## 行为守则\n- 直接行动,不预告。不说「我将要...」,直接调用工具\n- 不擅自扩大范围。用户要什么做什么,核心完成即止\n- 独立的工具调用一次发出,并行执行\n- 3 步以上的任务先用 todo_write 列任务清单,开工/完成时逐项更新状态\n- 写入后回读验证,汇报已验证状态而非仅尝试\n- 任务涉及专业能力时（PPT/Excel/PDF/网页设计/代码审查等），先调 list_skills 查看可用技能，再用 use_skill 激活`;
   }
 
   protected injectProgrammingWisdom(prompt: string): string {
@@ -159,16 +185,34 @@ export class BaseAgent {
     return prompt + `\n\n## 工程能力\n顶级工程师:类型安全、真实的错误处理、按根因调试、按安全与性能审查。你可以阅读和修改 Skyloom 自身源码。`;
   }
 
+  /** Layered SKY.md / CLAUDE.md / AGENTS.md project memory (see core/skymd). */
+  protected injectProjectMemory(prompt: string): string {
+    try {
+      const { loadProjectMemory } = require('./skymd');
+      const mem = loadProjectMemory();
+      if (!mem.text) return prompt;
+      return prompt + `\n\n## 项目记忆 (SKY.md)\n用户与项目维护的约定，优先级高于你的通用习惯：\n\n${mem.text}`;
+    } catch {
+      return prompt;
+    }
+  }
+
   reinitLanguage(): void {
     this._baseSystemPrompt = '';
     this._baseSystemPrompt = this.resolveSystemPrompt();
     this._baseSystemPrompt = this.injectWorkspaceInfo(this._baseSystemPrompt);
     this._baseSystemPrompt = this.injectBehaviorRules(this._baseSystemPrompt);
     this._baseSystemPrompt = this.injectProgrammingWisdom(this._baseSystemPrompt);
+    this._baseSystemPrompt = this.injectProjectMemory(this._baseSystemPrompt);
     this._baseSystemPrompt += '\n\n' + this.currentTimeTag();
     this.rebuildSystemPrompt();
   }
 
+  /** Re-read SKY.md layers into the system prompt (after `#` quick memory / edits). */
+  reloadProjectMemory(): void {
+    this.reinitLanguage();
+  }
+
   async init(): Promise<void> {
     if (this._baseSystemPrompt) return;
     await this.memory.initDb();
@@ -186,6 +230,7 @@ export class BaseAgent {
     this._baseSystemPrompt = this.injectWorkspaceInfo(this._baseSystemPrompt);
     this._baseSystemPrompt = this.injectBehaviorRules(this._baseSystemPrompt);
     this._baseSystemPrompt = this.injectProgrammingWisdom(this._baseSystemPrompt);
+    this._baseSystemPrompt = this.injectProjectMemory(this._baseSystemPrompt);
     this._baseSystemPrompt += '\n\n' + this.currentTimeTag();
     this.rebuildSystemPrompt();
     this._tools = this.toolRegistry.getTools();
@@ -212,6 +257,13 @@ export class BaseAgent {
       description: 'List all available skills with their names and descriptions. Use this first to discover what skills you can activate.',
       parameters: [],
       handler: async () => {
+        // live change detection: re-scan user/project skill folders so a
+        // SKILL.md edit or drop-in applies without restarting the session
+        try {
+          const { registerDynamicSkills } = require('../skills/loader');
+          registerDynamicSkills(self.skillRegistry);
+          self.loadSkills();
+        } catch { /* live reload is best-effort */ }
         const skills = self.getAvailableSkills();
         if (!skills.length) return 'No skills available.';
         const maxName = Math.max(...skills.map(s => s.name.length), 1);
@@ -553,9 +605,37 @@ export class BaseAgent {
         if (onStatus) onStatus(p.label);
         await this.setState(AgentState.ACTING);
 
+        // File checkpoint: snapshot the target before any mutating file tool
+        // runs, so /rewind can restore the pre-turn state.
+        try {
+          const { getFileCheckpoints } = require('./file_checkpoint');
+          const cp = getFileCheckpoints();
+          const snapPath = cp.pathToSnapshot(p.toolName, p.toolArgs || {});
+          if (snapPath) cp.snapshot(snapPath);
+        } catch { /* checkpointing must never block execution */ }
+
+        // pre_tool hooks are enforced policy: a non-zero exit blocks the call.
+        const hooks = this.getHooks();
+        if (hooks.preTool.length > 0) {
+          try {
+            const { runPreToolHooks } = require('./hooks');
+            const pre = runPreToolHooks(hooks, p.toolName, p.toolArgs || {}, this.name);
+            if (!pre.allowed) {
+              return { idx, result: { tc: p.tc, result: `[blocked by pre_tool hook] ${pre.reason}`, success: false, toolName: p.toolName } };
+            }
+          } catch { /* hook machinery must never break tool execution */ }
+        }
+
         try {
           const toolResult = await this.toolRegistry.execute(p.toolName, p.toolArgs || {});
           const resultStr = toolResult.result || toolResult.error || '(no output)';
+          if (toolResult.success && WRITE_TOOL_RE.test(p.toolName)) this._turnWroteFiles = true;
+          if (hooks.postTool.length > 0) {
+            try {
+              const { runPostToolHooks } = require('./hooks');
+              runPostToolHooks(hooks, p.toolName, p.toolArgs || {}, this.name);
+            } catch { /* best-effort */ }
+          }
           return { idx, result: { tc: p.tc, result: resultStr, success: toolResult.success, toolName: p.toolName } };
         } catch (e) {
           return { idx, result: { tc: p.tc, result: `Tool '${p.toolName}' execution failed: ${e}`, success: false, toolName: p.toolName } };
@@ -578,7 +658,9 @@ export class BaseAgent {
       }
     }
 
-    // Phase D: Record results to memory
+    // Phase D: Record results to memory (clamped — one runaway read_file or
+    // http_get must not flood the context window)
+    const resultLimit = Number((this.config as any)?.llm?.tool_result_limit) || undefined;
     for (const r of results) {
       if (!r) continue;
 
@@ -586,7 +668,7 @@ export class BaseAgent {
         if (suppressed) suppressed.add(r.toolName);
       }
 
-      this.memory.addMessage('tool', r.result, {
+      this.memory.addMessage('tool', clampToolResult(r.result, resultLimit), {
         name: r.toolName,
         toolCallId: r.tc.id,
         ephemeral,
@@ -726,7 +808,15 @@ export class BaseAgent {
     signal?: AbortSignal
   ): AsyncGenerator<Record<string, any>> {
     await this.setState(AgentState.THINKING);
-    this.memory.addMessage('user', message);
+    // Plan mode: the tag travels with the message so the model plans instead
+    // of acting, and the read-only tool filter below removes the temptation.
+    const userMessage = this.planMode
+      ? `[计划模式] 只读调研，不要执行任何修改。请输出一份编号的执行计划（涉及哪些文件、每步做什么、风险点），等待用户批准后再实施。\n\n${message}`
+      : message;
+    this.memory.addMessage('user', userMessage);
+    try {
+      require('./file_checkpoint').getFileCheckpoints().beginTurn(message);
+    } catch { /* optional */ }
     let assistantStored = false;
 
     if (this.shouldAutoCompact()) {
@@ -750,9 +840,16 @@ export class BaseAgent {
     let cacheKey: string | null = null;
 
     const resolveToolNames = (): string[] => {
-      const key = JSON.stringify([[...suppressedTools].sort(), [...this._activeSkills].sort()]);
+      const key = JSON.stringify([[...suppressedTools].sort(), [...this._activeSkills].sort(), this.planMode]);
       if (toolNamesCache !== null && cacheKey === key) return toolNamesCache;
       let candidates = this.activeToolNames().filter(t => !suppressedTools.has(t));
+      if (this.planMode) {
+        candidates = candidates.filter(n => {
+          if (SIDE_EFFECT_TOOL_RE.test(n)) return false;
+          const t = this.toolRegistry.get(n);
+          return !(t as any)?.dangerous;
+        });
+      }
       const must = new Set<string>();
       for (const s of this._skills) {
         if (this._activeSkills.has(s.name)) {
@@ -1029,6 +1126,25 @@ export class BaseAgent {
     };
   }
 
+  /** Per-role token breakdown for the /context command. */
+  contextDetail(): Record<string, any> {
+    const byRole: Record<string, { tokens: number; count: number }> = {};
+    for (const m of this.memory.shortTerm) {
+      const extra = (m as any).toolCalls ? JSON.stringify((m as any).toolCalls).length : 0;
+      const tokens = Math.ceil(((m.content || '').length + extra) / 4);
+      const slot = byRole[m.role] || (byRole[m.role] = { tokens: 0, count: 0 });
+      slot.tokens += tokens;
+      slot.count += 1;
+    }
+    return {
+      ...this.contextUsage(),
+      byRole,
+      systemPromptTokens: Math.ceil(this._baseSystemPrompt.length / 4),
+      toolCount: this.activeToolNames().length,
+      activeSkills: [...this._activeSkills],
+    };
+  }
+
   protected shouldAutoCompact(): boolean {
     const usage = this.memory.getContextWindowUsage();
     // Compact before hitting the real window — leave ~20% headroom for the reply.
@@ -1259,9 +1375,43 @@ export class BaseAgent {
 
     this.memory.addMessage('user', prompt);
     const preLen = this.memory.shortTerm.length;
+    this._turnWroteFiles = false;
+    try {
+      require('./file_checkpoint').getFileCheckpoints().beginTurn(`[task] ${task.description}`);
+    } catch { /* optional */ }
 
     try {
-      const response = await this.llmLoop({ onStatus, ephemeral: true });
+      let response = await this.llmLoop({ onStatus, ephemeral: true });
+
+      // ── 验证闭环: if this task touched the filesystem and verify commands
+      // are configured (config.verify or SKY.md "## Verify"), run them and
+      // feed failures back for a bounded number of fix rounds. ──
+      try {
+        const { resolveVerifyConfig, runVerify } = require('./verify');
+        const vc = resolveVerifyConfig(this.config);
+        if (vc.commands.length > 0 && this._turnWroteFiles) {
+          for (let round = 0; round <= vc.maxFixRounds; round++) {
+            if (onStatus) onStatus(`verify: ${vc.commands.length} 条命令`);
+            const vr = runVerify(vc);
+            if (vr.ok) {
+              response.content += `\n\n[verify ✓ 全部通过]\n${vr.report}`;
+              break;
+            }
+            if (round === vc.maxFixRounds) {
+              response.content += `\n\n[verify ✗ 经 ${vc.maxFixRounds} 轮修复仍未通过]\n${vr.report.slice(0, 1500)}`;
+              break;
+            }
+            if (onStatus) onStatus(`verify 失败 — 修复第 ${round + 1}/${vc.maxFixRounds} 轮`);
+            log.warn('verify_failed_fixing', { agent: this.name, round: round + 1 });
+            this.memory.addMessage('user',
+              `[自动验证失败] 以下验证命令未通过。请定位根因并修复，确保它们全部通过：\n\n${vr.report}`);
+            response = await this.llmLoop({ onStatus, ephemeral: true });
+          }
+        }
+      } catch (e) {
+        log.warn('verify_loop_error', { error: String(e) });
+      }
+
       const filePaths = extractFilePathsFromMessages(this.memory.shortTerm.slice(preLen));
       const enriched = enrichResponseWithArtifacts(response.content, filePaths);
       this.memory.addMessage('assistant', enriched, { toolCalls: response.toolCalls, reasoningContent: response.reasoningContent });
@@ -1285,6 +1435,18 @@ export class BaseAgent {
   private _security: any = null;
   get security(): any { if (!this._security) { try { const { getSecurity } = require('./security'); this._security = getSecurity(); } catch { this._security = {}; } } return this._security; }
 
+  protected getHooks(): import('./hooks').Hooks {
+    if (!this._hooks) {
+      try {
+        const { loadHooks } = require('./hooks');
+        this._hooks = loadHooks(this.config);
+      } catch {
+        this._hooks = { sessionStart: [], preTool: [], postTool: [] };
+      }
+    }
+    return this._hooks!;
+  }
+
   protected async checkToolApproval(toolName: string, toolArgs: Record<string, any>): Promise<boolean> {
     try {
       const sec = this.security;

package/src/core/arbitrate.ts

@@ -1,162 +1,162 @@
-/**
- * 多Agent冲突仲裁 — majority voting, quality scoring, tie-breaking.
- *
- * When multiple agents produce conflicting outputs on the same task
- * (or when a reviewer disagrees with an executor), this module
- * provides structured conflict resolution.
- */
-
-import type { TaskExecutionResult } from "./factory";
-
-/* ═══════════════════════════════════════
-   Conflict detection
-   ═══════════════════════════════════════ */
-export interface Conflict {
-  taskId: string;
-  results: TaskExecutionResult[];
-  description: string;
-  severity: "low" | "medium" | "high";
-}
-
-/** Detect if two results conflict based on success status and content overlap. */
-export function detectConflicts(results: TaskExecutionResult[]): Conflict[] {
-  const byTask = new Map<string, TaskExecutionResult[]>();
-  for (const r of results) { const id = r.id; if (!byTask.has(id)) byTask.set(id, []); byTask.get(id)!.push(r); }
-
-  const conflicts: Conflict[] = [];
-  for (const [id, items] of byTask) {
-    if (items.length < 2) continue;
-
-    const successes = items.filter(r => r.success);
-    const failures = items.filter(r => !r.success);
-
-    // All succeeded — check content divergence
-    if (successes.length >= 2) {
-      const contents = successes.map(r => (r.content || "").toLowerCase());
-      const similarity = pairwiseSimilarity(contents);
-      if (similarity < 0.3) {
-        conflicts.push({ taskId: id, results: successes, description: "Multiple agents produced divergent successful outputs", severity: "medium" });
-      }
-    }
-
-    // Mix of success and failure
-    if (successes.length > 0 && failures.length > 0) {
-      conflicts.push({ taskId: id, results: items, description: `${successes.length} succeeded, ${failures.length} failed — need tiebreaker`, severity: "medium" });
-    }
-
-    // All failed
-    if (failures.length >= 2 && successes.length === 0) {
-      conflicts.push({ taskId: id, results: failures, description: "All agents failed on this task", severity: "high" });
-    }
-  }
-
-  return conflicts;
-}
-
-/* ═══════════════════════════════════════
-   Content similarity (n-gram Jaccard)
-   ═══════════════════════════════════════ */
-function pairwiseSimilarity(texts: string[]): number {
-  if (texts.length < 2) return 1.0;
-  let total = 0;
-  let count = 0;
-  for (let i = 0; i < texts.length; i++) {
-    for (let j = i + 1; j < texts.length; j++) {
-      total += ngramJaccard(texts[i], texts[j], 3);
-      count++;
-    }
-  }
-  return count === 0 ? 0 : total / count;
-}
-
-function ngramJaccard(a: string, b: string, n: number): number {
-  const as = ngrams(a, n), bs = ngrams(b, n);
-  if (as.size === 0 && bs.size === 0) return 1;
-  let intersection = 0;
-  for (const g of as) { if (bs.has(g)) intersection++; }
-  const union = as.size + bs.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-
-function ngrams(s: string, n: number): Set<string> {
-  const out = new Set<string>();
-  for (let i = 0; i <= s.length - n; i++) out.add(s.slice(i, i + n));
-  return out;
-}
-
-/* ═══════════════════════════════════════
-   Majority voting / arbitration
-   ═══════════════════════════════════════ */
-export interface ArbitrationResult {
-  winner: TaskExecutionResult;
-  method: "unanimous" | "majority" | "tiebreaker" | "single";
-  confidence: number; // 0-1
-  reasoning: string;
-}
-
-/** Pick the best result from conflicting ones via majority vote. */
-export function arbitrate(results: TaskExecutionResult[]): ArbitrationResult {
-  if (results.length === 0) throw new Error("No results to arbitrate");
-  if (results.length === 1) return { winner: results[0], method: "single", confidence: 0.8, reasoning: "Only one result available" };
-
-  const success = results.filter(r => r.success);
-  const fail = results.filter(r => !r.success);
-
-  // All agree (success)
-  if (success.length === results.length) {
-    const longest = success.reduce((a, b) => (b.content || "").length > (a.content || "").length ? b : a);
-    return { winner: longest, method: "unanimous", confidence: 0.95, reasoning: `${results.length}/${results.length} agents agreed` };
-  }
-
-  // Majority success
-  if (success.length > fail.length) {
-    // Pick the longest successful content (most detailed)
-    const best = success.reduce((a, b) => (b.content || "").length > (a.content || "").length ? b : a);
-    return { winner: best, method: "majority", confidence: success.length / results.length, reasoning: `${success.length}/${results.length} succeeded, selected most detailed` };
-  }
-
-  // Majority failure — pick the "closest to success" (longest content)
-  if (fail.length > success.length) {
-    const best = fail.reduce((a, b) => (b.content || "").length > (a.content || "").length ? b : a);
-    return { winner: best, method: "majority", confidence: 0.3, reasoning: `Majority failed (${fail.length}/${results.length}), best-effort from partial output` };
-  }
-
-  // Tie — prefer success, or longest content
-  const tie = success.length > 0 ? success[0] : fail[0];
-  return { winner: tie, method: "tiebreaker", confidence: 0.5, reasoning: `Tie — selected ${tie.success ? "success" : "longest"} result` };
-}
-
-/* ═══════════════════════════════════════
-   Quality scoring for individual results
-   ═══════════════════════════════════════ */
-export interface QualityScore {
-  score: number;         // 0-100
-  completeness: number;  // how much of the task was addressed
-  richness: number;      // detail level of the output
-  correctness: number;   // did it match expectations (requires ground truth)
-}
-
-export function scoreQuality(result: TaskExecutionResult): QualityScore {
-  const content = result.content || "";
-
-  // Completeness: length is a weak proxy but useful
-  const completeness = content.length > 500 ? 80 : content.length > 100 ? 50 : content.length > 0 ? 20 : 0;
-
-  // Richness: code blocks, structured output, bullet points
-  let richness = 50;
-  if (/```/.test(content)) richness += 20;
-  if (/\|.*\|.*\|/.test(content)) richness += 15; // tables
-  if (/^[-*] /.test(content)) richness += 10;      // bullets
-  if (/\d+\./.test(content)) richness += 10;        // numbered lists
-  richness = Math.min(100, richness);
-
-  // Correctness: basic sanity checks
-  let correctness = 70;
-  if (content.includes("Error") || content.includes("error")) correctness -= 20;
-  if (content.includes("[REDACTED]")) correctness -= 10;
-  if (content.includes("truncated")) correctness -= 15;
-  correctness = Math.max(0, correctness);
-
-  const score = Math.round((completeness * 0.3 + richness * 0.3 + correctness * 0.4));
-  return { score, completeness, richness, correctness };
-}
+/**
+ * 多Agent冲突仲裁 — majority voting, quality scoring, tie-breaking.
+ *
+ * When multiple agents produce conflicting outputs on the same task
+ * (or when a reviewer disagrees with an executor), this module
+ * provides structured conflict resolution.
+ */
+
+import type { TaskExecutionResult } from "./factory";
+
+/* ═══════════════════════════════════════
+   Conflict detection
+   ═══════════════════════════════════════ */
+export interface Conflict {
+  taskId: string;
+  results: TaskExecutionResult[];
+  description: string;
+  severity: "low" | "medium" | "high";
+}
+
+/** Detect if two results conflict based on success status and content overlap. */
+export function detectConflicts(results: TaskExecutionResult[]): Conflict[] {
+  const byTask = new Map<string, TaskExecutionResult[]>();
+  for (const r of results) { const id = r.id; if (!byTask.has(id)) byTask.set(id, []); byTask.get(id)!.push(r); }
+
+  const conflicts: Conflict[] = [];
+  for (const [id, items] of byTask) {
+    if (items.length < 2) continue;
+
+    const successes = items.filter(r => r.success);
+    const failures = items.filter(r => !r.success);
+
+    // All succeeded — check content divergence
+    if (successes.length >= 2) {
+      const contents = successes.map(r => (r.content || "").toLowerCase());
+      const similarity = pairwiseSimilarity(contents);
+      if (similarity < 0.3) {
+        conflicts.push({ taskId: id, results: successes, description: "Multiple agents produced divergent successful outputs", severity: "medium" });
+      }
+    }
+
+    // Mix of success and failure
+    if (successes.length > 0 && failures.length > 0) {
+      conflicts.push({ taskId: id, results: items, description: `${successes.length} succeeded, ${failures.length} failed — need tiebreaker`, severity: "medium" });
+    }
+
+    // All failed
+    if (failures.length >= 2 && successes.length === 0) {
+      conflicts.push({ taskId: id, results: failures, description: "All agents failed on this task", severity: "high" });
+    }
+  }
+
+  return conflicts;
+}
+
+/* ═══════════════════════════════════════
+   Content similarity (n-gram Jaccard)
+   ═══════════════════════════════════════ */
+function pairwiseSimilarity(texts: string[]): number {
+  if (texts.length < 2) return 1.0;
+  let total = 0;
+  let count = 0;
+  for (let i = 0; i < texts.length; i++) {
+    for (let j = i + 1; j < texts.length; j++) {
+      total += ngramJaccard(texts[i], texts[j], 3);
+      count++;
+    }
+  }
+  return count === 0 ? 0 : total / count;
+}
+
+function ngramJaccard(a: string, b: string, n: number): number {
+  const as = ngrams(a, n), bs = ngrams(b, n);
+  if (as.size === 0 && bs.size === 0) return 1;
+  let intersection = 0;
+  for (const g of as) { if (bs.has(g)) intersection++; }
+  const union = as.size + bs.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+
+function ngrams(s: string, n: number): Set<string> {
+  const out = new Set<string>();
+  for (let i = 0; i <= s.length - n; i++) out.add(s.slice(i, i + n));
+  return out;
+}
+
+/* ═══════════════════════════════════════
+   Majority voting / arbitration
+   ═══════════════════════════════════════ */
+export interface ArbitrationResult {
+  winner: TaskExecutionResult;
+  method: "unanimous" | "majority" | "tiebreaker" | "single";
+  confidence: number; // 0-1
+  reasoning: string;
+}
+
+/** Pick the best result from conflicting ones via majority vote. */
+export function arbitrate(results: TaskExecutionResult[]): ArbitrationResult {
+  if (results.length === 0) throw new Error("No results to arbitrate");
+  if (results.length === 1) return { winner: results[0], method: "single", confidence: 0.8, reasoning: "Only one result available" };
+
+  const success = results.filter(r => r.success);
+  const fail = results.filter(r => !r.success);
+
+  // All agree (success)
+  if (success.length === results.length) {
+    const longest = success.reduce((a, b) => (b.content || "").length > (a.content || "").length ? b : a);
+    return { winner: longest, method: "unanimous", confidence: 0.95, reasoning: `${results.length}/${results.length} agents agreed` };
+  }
+
+  // Majority success
+  if (success.length > fail.length) {
+    // Pick the longest successful content (most detailed)
+    const best = success.reduce((a, b) => (b.content || "").length > (a.content || "").length ? b : a);
+    return { winner: best, method: "majority", confidence: success.length / results.length, reasoning: `${success.length}/${results.length} succeeded, selected most detailed` };
+  }
+
+  // Majority failure — pick the "closest to success" (longest content)
+  if (fail.length > success.length) {
+    const best = fail.reduce((a, b) => (b.content || "").length > (a.content || "").length ? b : a);
+    return { winner: best, method: "majority", confidence: 0.3, reasoning: `Majority failed (${fail.length}/${results.length}), best-effort from partial output` };
+  }
+
+  // Tie — prefer success, or longest content
+  const tie = success.length > 0 ? success[0] : fail[0];
+  return { winner: tie, method: "tiebreaker", confidence: 0.5, reasoning: `Tie — selected ${tie.success ? "success" : "longest"} result` };
+}
+
+/* ═══════════════════════════════════════
+   Quality scoring for individual results
+   ═══════════════════════════════════════ */
+export interface QualityScore {
+  score: number;         // 0-100
+  completeness: number;  // how much of the task was addressed
+  richness: number;      // detail level of the output
+  correctness: number;   // did it match expectations (requires ground truth)
+}
+
+export function scoreQuality(result: TaskExecutionResult): QualityScore {
+  const content = result.content || "";
+
+  // Completeness: length is a weak proxy but useful
+  const completeness = content.length > 500 ? 80 : content.length > 100 ? 50 : content.length > 0 ? 20 : 0;
+
+  // Richness: code blocks, structured output, bullet points
+  let richness = 50;
+  if (/```/.test(content)) richness += 20;
+  if (/\|.*\|.*\|/.test(content)) richness += 15; // tables
+  if (/^[-*] /.test(content)) richness += 10;      // bullets
+  if (/\d+\./.test(content)) richness += 10;        // numbered lists
+  richness = Math.min(100, richness);
+
+  // Correctness: basic sanity checks
+  let correctness = 70;
+  if (content.includes("Error") || content.includes("error")) correctness -= 20;
+  if (content.includes("[REDACTED]")) correctness -= 10;
+  if (content.includes("truncated")) correctness -= 15;
+  correctness = Math.max(0, correctness);
+
+  const score = Math.round((completeness * 0.3 + richness * 0.3 + correctness * 0.4));
+  return { score, completeness, richness, correctness };
+}