@sema-agent/server 7.82.1 → 7.83.0

package/dist/bench/s1/arms.d.ts

@@ -22,7 +22,7 @@
  *  3. WORKER-ENV: the repair leg ALWAYS passes `workerEnv` so runRepairLoop's §5.1 isolation identity check is LIVE.
  *  4. PAIRED-SEED: `seed` is best-effort N-repeat replicate, NEVER a GO criterion; rows are distributional.
  *  5. COMPLETE TEAM COST: TEAM stats = Σ(worker stats.costBreakdown) + (merge.repair?.costUsd) +
- *     (merge.conflictResolverCostUsd) — all three legs (the resolver cost was just un-dropped, merge.ts).
+ *     两条腿(7.83.0 起:冲突解决模型已随 [ref] ④ 删除,不再有第三条 resolver 腿)。
  *
  * 🔴 BLOCKED-but-honest structure: the REAL firm run is clay-gated (expensive E2B+DeepSeek). This file builds the
  * REAL arm logic against INJECTABLE profile seams (`ProfileDeps`) so the deterministic smoke drives it with a MOCK
@@ -143,9 +143,9 @@ export declare function classifyRunStatus(input: {
  */
 export declare function captureStats(stats: TaskResult["stats"] | undefined): EmittedStats;
 /**
- * 🔴 Corr #5 — the COMPLETE TEAM `stats`. Σ(worker stats.costBreakdown + humanReview) PLUS the merge legs:
- * `repair?.costUsd` and `conflictResolverCostUsd` (the resolver cost was just un-dropped in merge.ts). All three
- * legs, or TEAM C1 is undercounted ([ref]'s #1 confound). costUsd (float USD) → µUSD into llmRoot.
+ * 🔴 Corr #5 — the COMPLETE TEAM `stats`. Σ(worker stats.costBreakdown + humanReview) PLUS the merge leg
+ * `repair?.costUsd`. Both legs, or TEAM C1 is undercounted ([ref]'s #1 confound). costUsd (float USD) →
+ * µUSD into llmRoot. (7.83.0:第三条腿 `conflictResolverCostUsd` 随冲突解决模型删除,见下。)
  */
 export declare function captureTeamStats(reports: WorkerReport[], merge: MergeResult | undefined): EmittedStats;
 /**

package/dist/bench/s1/arms.js

@@ -60,8 +60,7 @@ export function captureTeamStats(reports, merge) {
         acc.humanReview.gates.push(...s.humanReview.gates);
     }
     const repairUsd = merge?.repair?.costUsd ?? 0;
-    const resolverUsd = merge?.conflictResolverCostUsd ?? 0;
-    acc.costBreakdown.llmRootMicroUsd += Math.round((repairUsd + resolverUsd) * 1e6);
+    acc.costBreakdown.llmRootMicroUsd += Math.round(repairUsd * 1e6);
     return acc;
 }
 export async function driveSupSuspendResume(initial, deps, implSpec, trap, advanceClock) {

package/dist/bench/s1/live-deps.js

@@ -362,7 +362,6 @@ async function runLeaderForTrap(rt, brain, models, roles, pricing, trap, cellId,
     const targetRef = "refs/heads/main";
     process.env.LEADER_ENABLED = "true";
     process.env.LEADER_WORKER_BUDGET_USD = String((rt.maxCostUsd ?? 1.0) / 2);
-    process.env.LEADER_CONFLICT_ROUNDS = process.env.LEADER_CONFLICT_ROUNDS ?? "2";
     const run = createLeaderRunner({
         brain, models, roles, pricing, e2bApiKey: rt.e2bApiKey, workspace: W,
         ...(s1DebugGit() ? { logger: { warn: (m, x) => console.error(`[S1_DEBUG_LEADER warn] ${m}`, x ? JSON.stringify(x).slice(0, 300) : ""), info: (m, x) => console.error(`[S1_DEBUG_LEADER info] ${m}`, x ? JSON.stringify(x).slice(0, 200) : "") } } : {}),

package/dist/bench/s1/runner-ctx.d.ts

@@ -8,9 +8,9 @@
  * `maxTokens`/`maxCostUsd` is a silently-unread dead key), and TEAM's per-worker budgets sum to ≤ the solo budget — so no
  * arm can win on a bigger pie. `assertBudgetMatch` (below) is the build-time guard the shape test runs.
  *
- * 🔴 BUDGET-MATCH for TEAM is NEW WIRING the live conflict test does NOT do: `leader-conflict-resolver-live.test.ts`
- * sets NO budget on `SubtaskSpec.spec` and NO `now` on any Runner. The harness STAMPS both (arms.ts) — copying the
- * live test verbatim would yield an unbounded TEAM (the confound) and an empty `humanReview` (C2 = undefined).
+ * 🔴 BUDGET-MATCH for TEAM is NEW WIRING no leader live test does: the (now-deleted, 7.83.0 / [ref] ④) conflict
+ * live test set NO budget on `SubtaskSpec.spec` and NO `now` on any Runner. The harness STAMPS both (arms.ts) —
+ * copying a live test verbatim would yield an unbounded TEAM (the confound) and an empty `humanReview` (C2 = undefined).
  *
  * The real-infra construction (E2B worker/grader envs + a live brain) is deferred to the live make-real proof
  * (`test/s1-value-live.test.ts`, gated on E2B+DEEPSEEK). This module only fixes the SHAPE + the budget invariant

package/dist/bench/s1/tasks.d.ts

@@ -3,7 +3,9 @@
  *
  * 🔴 FIRM vs DIRECTIONAL (a HIGH review correction — do NOT reproduce the false "5 LIVE-VERIFIED" claim):
  * Only C1 / C2 / C4 have a real E2B+DeepSeek live make-real test in `test/` today
- *   (supervisor-verify-fix-live / supervisor-honest-bound-live / leader-conflict-resolver-live).
+ *   (supervisor-verify-fix-live / supervisor-honest-bound-live;C4 的那条 `leader-conflict-resolver-live`
+ *   已随 7.83.0 / clay [ref] ④ **删除** —— 它证的是「冲突解决模型合两边」,而那条通道不存在了;C4 今天
+ *   没有 live 证明位,按 DIRECTIONAL 计,不得再算作 FIRM).
  * C3 (honest-PARTIAL) has NO dedicated live test; C5 (safety-escalate) is ONLY a unit test
  *   (`supervisor-safety-escalate.test.ts` header: "no E2B / no DeepSeek / no DB" — it only exercises
  *   `createDurableAskPolicy` in-memory, NEVER a real boundary). Counting either as a measured datapoint is the
@@ -84,9 +86,11 @@ export declare const C1_VERIFY_FIX: TrapSpec;
  */
 export declare const C2_HONEST_BOUND: TrapSpec;
 /**
- * C4 — fan-out CONFLICT (two workers overlap one file → merge conflict → the bounded resolver keeps both).
- * FIRM (leader-conflict-resolver-live.test.ts). TEAM-primary. Objective COMMAND oracle = both functions exist
- * AND compute correctly.
+ * C4 — fan-out CONFLICT (two workers overlap one file → merge conflict).
+ * 🔴 7.83.0 / clay [ref] ④:合不上不再起解决模型,leader 把 `conflict` 段(分支 + 冲突文件)交给用户、
+ * run 状态 `needs_human` ⇒ 这一格的 TEAM 臂在冲突形上**不会自己合好**。原 FIRM 证明位
+ * (`leader-conflict-resolver-live` live 测试)随通道删除,C4 退回 DIRECTIONAL。TEAM-primary。
+ * Objective COMMAND oracle = both functions exist AND compute correctly.
  */
 export declare const C4_PARALLEL: TrapSpec;
 /**

package/dist/config-catalog.js

@@ -184,7 +184,6 @@ export const CONFIG_CATALOG = [
     r("KUBERNETES_SERVICE_HOST", "orchestration", "string", "平台注入的 in-cluster k8s API host(K8S_API_URL 缺席时用)"),
     r("KUBERNETES_SERVICE_PORT", "orchestration", "string", "平台注入的 in-cluster k8s API 端口(缺省 443)"),
     r("LEADER_BUDGET_USD", "orchestration", "number", "leader replan-lite 扇出花费帽(USD)", { danger: BILL, derivedDefaultNote: "缺席 ⇒ replan-lite 自默认" }),
-    r("LEADER_CONFLICT_ROUNDS", "orchestration", "number", "leader 合并冲突修复轮数", { danger: BILL, derivedDefaultNote: "缺席 ⇒ 场景配置 conflictRounds(默认 0)" }),
     r("LEADER_ENABLED", "orchestration", "boolean", "leader 端点(POST/GET /v1/leader;需隔离执行后端 + durable leader_run 店,缺则拒启)", { staticDefault: "false", configKey: "leaderEnabled" }),
     r("LEADER_FANOUT_ENABLED", "orchestration", "boolean", "leader 扇出许可(false=钉死单路由零 router 成本)", { staticDefault: "true", danger: BILL, configKey: "leaderFanoutEnabled" }),
     r("LEADER_MEASURE_GATES", "orchestration", "boolean", "leader 合并 push-hold-on-signal + measure-drives-repair 门(严格 'true' 才开)", { staticDefault: "false" }),

package/dist/config.js

@@ -119,6 +119,7 @@ const RETIRED_ENVS = [
     ["OA_ISSUE_REPO", "the OA scenario was removed in 5.0.0", "removed"],
     ["OA_ISSUE_LABELS", "the OA scenario was removed in 5.0.0", "removed"],
     ["APPROVAL_POLL_MS", "the OA poll-approval lane was removed in 5.0.0; the durable checkpoint lane is the only gate", "removed"],
+    ["LEADER_CONFLICT_ROUNDS", "the bounded merge-conflict-resolution agent was deleted in 7.83.0 按 C-R63 删除,合不上交用户:leader 交回 result.conflict(分支 + 冲突文件),run 状态 needs_human", "removed"],
 ];
 function rejectRetiredEnvs() {
     const hit = RETIRED_ENVS.filter(([o]) => process.env[o] !== undefined && process.env[o] !== "");

package/dist/leader/endpoint.js

@@ -3,6 +3,8 @@ import { redactErrorMessage, redactHead, redactLeaderResult, redactLeaderResultW
 import { withPrincipal } from "../observability/principal-context.js";
 import { leaderIdemKey } from "../plugins/leader-run-store-sql.js";
 function statusForLeaderResult(result) {
+    if (result.conflict)
+        return "needs_human";
     switch (result.repairTerminal) {
         case "candidate_only":
         case "needs_human_oracle":

package/dist/leader/leader.d.ts

@@ -104,10 +104,13 @@ export interface LeaderDeps {
     /** Replan-lite ([ref] §6): bounded, DETERMINISTIC reactions — no runtime DAG surgery. When set:
      *  worker failed → redispatch ×1 on a FRESH env (clean base; a crashed worker's half-written workspace is
      *  never reused) → still failed = collapse-remainder-to-single; verify FAIL (repair already bounded inside
-     *  the verify loop) → collapse; structural merge conflict → collapse + record; budgetUsd exceeded → stop
-     *  fan-out, single continues. Multi-trigger arbitration priority (C6): suspended > budget > merge-conflict >
-     *  verify-fail > worker-failed — only the highest-priority reaction runs. (The suspended reaction itself —
-     *  cancel the others, exempt the suspended worker, surface its token — is unconditional, not gated here.) */
+     *  the verify loop) → collapse; budgetUsd exceeded → stop fan-out, single continues. Multi-trigger
+     *  arbitration priority (C6): suspended > budget > verify-fail > worker-failed — only the highest-priority
+     *  reaction runs. (The suspended reaction itself — cancel the others, exempt the suspended worker, surface
+     *  its token — is unconditional, not gated here.)
+     *
+     *  🔴 S-113 / clay [ref] ④(7.83.0):**merge-conflict 不再是一条 replan 臂**。worker 分支合不上 ⇒ 不起
+     *  collapse 模型,`conflict` 段(分支 + 冲突文件)交给**用户**,见 {@link LeaderResult.conflict}。 */
     replan?: {
         /** Fan-out budget (USD, sum of worker costs). Exceeded → stop fan-out, collapse to single (C5). */
         budgetUsd?: number;
@@ -154,12 +157,36 @@ export interface LeaderResult {
     route?: "single" | "fanout";
     /** Set when planning/provisioning failed before fan-out. */
     error?: string;
-    /** Replan-lite ([ref] §6): which trigger won arbitration + what was done. */
+    /** Replan-lite ([ref] §6): which trigger won arbitration + what was done.
+     *  🔴 S-113 / [ref] ④(7.83.0):闭集删掉 `"merge-conflict"`(硬 breaking,零别名——消费方的 tsc 红即通知)。 */
     replan?: {
-        trigger: "suspended" | "budget" | "merge-conflict" | "verify-fail" | "worker-failed";
+        trigger: "suspended" | "budget" | "verify-fail" | "worker-failed";
         redispatched?: string[];
         collapsed?: string;
     };
+    /**
+     * 🔴 S-113 / clay [ref] ④(7.83.0)——**合不上 = 交给用户**(对齐 CC 形)。merge 的 `phase:"apply"` 冲突
+     * 不再起 collapse 模型:`ok=false` + 本段,用户拿 `workers[].branch` + `files` 自己 `git merge` / cherry-pick
+     * (worker 分支本就留在集成沙箱 / 远端)。run 状态走既有第三终局 `needs_human`(endpoint 的状态映射),不加
+     * 新状态词。**缺席何义** = 这一趟没有冲突,或对面是老 server。
+     */
+    conflict?: {
+        /** 用户侧的合并基点 = leader 这一趟的 durable base。 */
+        baseSha: string;
+        /** 有冲突标记 / `.rej` 的路径(**不含内容**)。 */
+        files: string[];
+        /** 清单被截断(探测到的冲突路径多于上限)时在场;**缺席 = 这就是全部**(对抗复审 F5)。 */
+        filesTruncated?: true;
+        /** 全部 completed worker 的分支;`applied:false` = 这只 worker 的补丁没进树(冲突者本人,或排在它后面
+         *  还没轮到 apply 的——顺序 apply,首次失败即停)。 */
+        workers: Array<{
+            workerId: string;
+            branch: string;
+            applied: boolean;
+        }>;
+        /** `.rej` 头(经既有脱敏面,≤ 2 KiB)——给人看冲突长什么样。 */
+        rejHead?: string;
+    };
     /** C4: suspended workers' resume tokens, surfaced to the caller (their checkpoints + paused envs are intact —
      *  the single-agent resume path owns them from here; orphan protection = the existing deadline reap). */
     suspended?: Array<{

package/dist/leader/leader.js

@@ -1,8 +1,8 @@
 import { fanOut } from "./fanout.js";
-import { redactErrorMessage, redactHead, redactPatchHead } from "../observability/run-terminal-log.js";
+import { redactErrorMessage, redactHead } from "../observability/run-terminal-log.js";
 import { pullDiff } from "./diffout.js";
 import { mergeBranches } from "./merge.js";
-import { Runner, runWithVerification, resumeWithVerification, delimitUntrusted, terminalProjection } from "@sema-agent/core";
+import { Runner, runWithVerification, resumeWithVerification, terminalProjection } from "@sema-agent/core";
 import { pausedCauseOf } from "../terminal.js";
 const MAX_RESUME_SLICES = 200;
 export async function autoResumeOnResource(initial, signal, resume, maxSlices = MAX_RESUME_SLICES) {
@@ -152,20 +152,25 @@ export async function runLeaderTask(task, durableBaseSha, deps) {
             : w.diffEnv
                 ? pullDiff(w.diffEnv, w.baseSha, { ref: w.branch, ...(workerRepoDir ? { cwd: workerRepoDir } : {}) })
                 : Promise.resolve({ ok: false, error: `worker ${w.workerId} has neither fetchDiff nor diffEnv` });
-        const salvageNonCompleted = async (rs) => {
+        const notCompleted = (r) => r.status !== "completed";
+        const salvagePatches = async (rs) => {
             const out = [];
+            const skipped = (workerId, why, detail) => deps.logger?.warn?.("salvage_skipped", { workerId, why, ...(detail ? { detail: redactHead(detail, 200) } : {}) });
             await Promise.all(rs
-                .filter((r) => r.status !== "completed")
                 .map(async (r) => {
                 const w = byId.get(r.workerId);
                 if (!w)
-                    return;
+                    return skipped(r.workerId, "unknown_worker");
                 try {
                     const d = await workerDiff(w);
-                    if (d.ok && d.patch.trim().length > 0)
-                        out.push({ workerId: r.workerId, sessionId: r.sessionId, patch: d.patch });
+                    if (!d.ok)
+                        return skipped(r.workerId, "diff_failed", d.error);
+                    if (d.patch.trim().length === 0)
+                        return skipped(r.workerId, "empty_diff");
+                    out.push({ workerId: r.workerId, sessionId: r.sessionId, patch: d.patch });
                 }
-                catch {
+                catch (e) {
+                    skipped(r.workerId, "diff_threw", e instanceof Error ? e.message : String(e));
                 }
             }));
             return out;
@@ -226,7 +231,7 @@ export async function runLeaderTask(task, durableBaseSha, deps) {
             if (sus.length === 0)
                 return undefined;
             deps.logger?.info?.("replan_suspended", { workers: sus.map((r) => r.workerId) });
-            const salvaged = await salvageNonCompleted(rs);
+            const salvaged = await salvagePatches(rs.filter(notCompleted));
             return {
                 ok: false, reports: rs, cancelled: true, route,
                 error: "worker suspended — fan-out cancelled (suspended worker exempt), resume token surfaced",
@@ -235,41 +240,26 @@ export async function runLeaderTask(task, durableBaseSha, deps) {
                 ...(salvaged.length > 0 ? { salvaged } : {}),
             };
         };
-        const collapseToSingle = async (trigger, reason, priorMerge) => {
+        const conflictSegment = (c, rs) => ({
+            baseSha: durableBaseSha,
+            files: c.files,
+            ...(c.filesTruncated ? { filesTruncated: true } : {}),
+            workers: rs
+                .filter((r) => r.status === "completed")
+                .map((r) => ({ workerId: r.workerId, branch: byId.get(r.workerId).branch, applied: c.applied.includes(r.workerId) })),
+            ...(c.rejHead ? { rejHead: c.rejHead } : {}),
+        });
+        const collapseToSingle = async (trigger, reason) => {
             const safeReason = redactHead(reason, 300);
             deps.logger?.warn?.("replan_collapse_to_single", { trigger, reason: safeReason });
             const replan = { trigger, collapsed: safeReason, ...(redispatched ? { redispatched } : {}) };
-            const priorDiffs = [];
-            await Promise.all(reports.map(async (r) => {
-                const w = byId.get(r.workerId);
-                if (!w)
-                    return;
-                try {
-                    const d = await workerDiff(w);
-                    if (d.ok && d.patch.trim().length > 0)
-                        priorDiffs.push({ workerId: r.workerId, status: r.status, patch: d.patch });
-                }
-                catch {
-                }
-            }));
-            if (priorDiffs.length > 0)
-                deps.logger?.info?.("collapse_reuse_priors", { workers: priorDiffs.map((d) => d.workerId) });
-            const soloObjective = priorDiffs.length === 0
-                ? task
-                : [
-                    task,
-                    ``,
-                    `--- PRIOR PARALLEL WORK — REUSE IT, do not re-derive from scratch ---`,
-                    `${priorDiffs.length} worker(s) attempted this task in parallel; their changes could NOT be integrated cleanly (${safeReason.slice(0, 150)}). Each worker's diff over the base is below. COPY the correct, non-overlapping parts verbatim and produce ONE coherent change for the WHOLE task, resolving only the overlaps. Treat these as a strong starting point — fix anything wrong, but do not throw the work away.`,
-                    ...priorDiffs.map((d) => delimitUntrusted(`PRIOR WORKER '${d.workerId}' (${d.status}) DIFF (untrusted)`, redactPatchHead(d.patch, 8000))),
-                ].join("\n");
-            const soloSub = { workerId: "collapse-solo", branch: "worker/collapse-solo", files: ["."], spec: { objective: soloObjective } };
+            const soloSub = { workerId: "collapse-solo", branch: "worker/collapse-solo", files: ["."], spec: { objective: task } };
             let solo;
             try {
                 solo = await deps.provisionWorker(soloSub);
             }
             catch (e) {
-                const salvaged = await salvageNonCompleted(finalReports);
+                const salvaged = await salvagePatches(finalReports.filter(notCompleted));
                 return { ok: false, reports: finalReports, cancelled, route, error: `collapse provision failed: ${e instanceof Error ? e.message : String(e)}`, replan, ...(salvaged.length > 0 ? { salvaged } : {}) };
             }
             workers.push(solo);
@@ -280,10 +270,20 @@ export async function runLeaderTask(task, durableBaseSha, deps) {
             const sus = await surfaceSuspended(finalReports, fo.reports);
             if (sus)
                 return { ...sus, replan: { ...replan, trigger: "suspended" }, ...(repairTerminal ? { repairTerminal } : {}), ...(candidatePatch ? { candidatePatch } : {}) };
-            const mRaw = await mergeBranches(fo.reports, durableBaseSha, mergeDeps);
-            const priorCost = priorMerge?.conflictResolverCostUsd ?? 0;
-            const m = priorCost > 0 ? { ...mRaw, conflictResolverCostUsd: (mRaw.conflictResolverCostUsd ?? 0) + priorCost } : mRaw;
-            const salvaged = await salvageNonCompleted(finalReports);
+            const m = await mergeBranches(fo.reports, durableBaseSha, mergeDeps);
+            if (!m.ok && m.conflict) {
+                const cc = m.conflict;
+                deps.logger?.warn?.("merge_conflict_to_user", { conflicted: cc.conflicted, applied: cc.applied, files: cc.files.slice(0, 20) });
+                const salvagedAll = await salvagePatches(finalReports);
+                return {
+                    ok: false, reports: finalReports, merge: m, cancelled: fo.cancelled, route, replan,
+                    conflict: conflictSegment(cc, fo.reports),
+                    ...(salvagedAll.length > 0 ? { salvaged: salvagedAll } : {}),
+                    ...(repairTerminal ? { repairTerminal } : {}),
+                    ...(candidatePatch ? { candidatePatch } : {}),
+                };
+            }
+            const salvaged = await salvagePatches(finalReports.filter(notCompleted));
             return {
                 ok: m.ok, reports: finalReports, merge: m, cancelled: fo.cancelled, route, replan,
                 ...(salvaged.length > 0 ? { salvaged } : {}),
@@ -336,18 +336,27 @@ export async function runLeaderTask(task, durableBaseSha, deps) {
                 const sus2 = await surfaceSuspended(reports, fo2.reports);
                 if (sus2)
                     return sus2;
-                const stillFailed = fo2.reports.filter((r) => r.status !== "completed").map((r) => r.workerId);
+                const stillFailed = fo2.reports.filter(notCompleted).map((r) => r.workerId);
                 if (stillFailed.length > 0) {
                     return collapseToSingle("worker-failed", `redispatch failed again: ${stillFailed.join(", ")}`);
                 }
             }
         }
         const merge = await mergeBranches(reports, durableBaseSha, mergeDeps);
-        if (!merge.ok && merge.phase === "apply" && deps.replan) {
-            deps.logger?.warn?.("replan_merge_conflict", { reason: merge.reason, quarantine: merge.quarantine ?? [] });
-            return collapseToSingle("merge-conflict", merge.reason, merge);
+        if (!merge.ok && merge.conflict) {
+            const c = merge.conflict;
+            deps.logger?.warn?.("merge_conflict_to_user", { conflicted: c.conflicted, applied: c.applied, files: c.files.slice(0, 20) });
+            const salvagedC = await salvagePatches(reports);
+            return {
+                ok: false, reports, merge, cancelled, route,
+                conflict: conflictSegment(c, reports),
+                ...(redispatched ? { replan: { trigger: "worker-failed", redispatched } } : {}),
+                ...(salvagedC.length > 0 ? { salvaged: salvagedC } : {}),
+                ...(repairTerminal ? { repairTerminal } : {}),
+                ...(candidatePatch ? { candidatePatch } : {}),
+            };
         }
-        const salvaged = await salvageNonCompleted(reports);
+        const salvaged = await salvagePatches(reports.filter(notCompleted));
         return {
             ok: merge.ok, reports, merge, cancelled, route,
             ...(redispatched ? { replan: { trigger: "worker-failed", redispatched } } : {}),

package/dist/leader/merge.d.ts

@@ -4,7 +4,8 @@
  * The deterministic Coordinator integrates N completed workers' branches under FULL isolation:
  *   1. pull each worker's patch OUT of its container (M2 `pullDiff` — no creds go in).
  *   2. provision an EPHEMERAL no-net/no-creds integration sandbox (base pre-provisioned by the dep).
- *   3. `git apply --3way` each patch in sequence (partial-apply → capture `.rej`, quarantine — council#3).
+ *   3. `git apply --3way` each patch in sequence (conflict ⇒ TERMINAL: capture `.rej` + the conflict PATH list and
+ *      hand them to the USER as {@link MergeConflict} — S-113 / clay [ref] ④; council#3's quarantine unchanged).
  *   4. run the full test suite IN the sandbox (the gate; untrusted diff never touches the control plane — [26]§16).
  *   5. green → the **Coordinator** (trusted control plane, holds creds — NOT the sandbox, council#1) takes the
  *      integrated patch and pushes with CAS `--force-with-lease=<ref>:<baseSha>` (push race → retry — council#2).
@@ -57,31 +58,25 @@ export interface IntegrationRepair {
     }>;
 }
 /**
- * Bounded merge-conflict resolution (search 2026-06-16). Symmetric with {@link IntegrationRepair}: when a worker's
- * patch CONFLICTS on `git apply --3way` (overlapping edits a sibling already touched), run a bounded agent IN the
- * integration sandbox to integrate THIS worker's patch — instead of the leader discarding ALL fan-out work and
- * redoing the whole task as one fresh worker (collapseToSingle, leader.ts: "correctness over thrift; half-done
- * adoption is future"). The agent merges the in-tree conflict markers + applies the `.rej` hunks; mergeBranches
- * then VERIFIES no marker/.rej remains before continuing, and the downstream test gate still guards correctness.
- * Wired by the caller (provisionIntegrationSandbox); when unset, an apply conflict stays terminal exactly as before
- * (zero behaviour change). Reuses the IntegrationRepair sandbox + hands pattern → no new core/env seam (the seam
- * [ref] §8 feared for "adopting N half-done workspaces" is unnecessary for the conflict case).
+ * S-113 / clay [ref] ④ — **合不上 = 交给用户**(对齐 CC 形)。`git apply --3way` 冲突时的产出:冲突**路径**
+ * (不含内容)+ 哪几只 worker 的补丁已经进树,由 leader 铸成 `LeaderResult.conflict` 段交到用户手上。
+ * 本段刻意**只有路径与身份**:CC 259 语料对 collapse / conflict resolution 零命中,CC 的并行是同机 teammates
+ * 各 worktree、结束由 git 重放到用户 HEAD、冲突列给用户(cli259.js @2303113)——没有任何模型去读别的 worker
+ * 的 diff。7.83.0 删掉的那条「冲突解决模型」通道(它的类型面与 `LEADER_CONFLICT_ROUNDS` 旋钮)正是此意。
  */
-export interface ConflictResolver {
-    /** Max resolution attempts before giving up (each = one agent run + one marker/.rej re-check). */
-    maxRounds: number;
-    /** Run the resolver agent against the live conflicted tree. Edits the working tree to integrate the worker's
-     *  patch + removes the `.rej`/`.orig` files; MUST NOT commit / push / add (the merge squashes at the end). */
-    run(ctx: {
-        round: number;
-        workerId: string;
-        conflictText: string;
-        patch: string;
-        repoDir: string;
-    }): Promise<{
-        costUsd?: number;
-        note?: string;
-    }>;
+export interface MergeConflict {
+    /** 有冲突标记或 `.rej` 的路径(**不含内容**;`.rej` 后缀已剥,指向源文件)。 */
+    files: string[];
+    /** 对抗复审 F5 [medium]:清单**被截断**(命中 {@link CONFLICT_FILES_MAX})时在场 —— 缺席 = 这就是全部。
+     *  「完整清单」是本终局对用户的补偿,一次静默的 200 封顶会让用户以为冲突只有 200 处。 */
+    filesTruncated?: true;
+    /** 冲突发生**之前**已经干净 apply 进树的 workerId(顺序 apply,失败即停)。 */
+    applied: string[];
+    /** 补丁没能 apply 的那只 worker。 */
+    conflicted: string;
+    /** `.rej` 头(经既有**工件**脱敏面 `redactArtifactText` —— 与 `rej` 同一批 diff 字节同一口 —— 再切 ≤ 2 KiB)
+     *  ——给用户看「冲突长什么样」,不是给模型的输入。 */
+    rejHead?: string;
 }
 export interface MergeDeps {
     /** Pull one worker's patch from ITS container (M2 pullDiff bound to the worker's env). */
@@ -93,7 +88,6 @@ export interface MergeDeps {
         env: IntegrationEnv;
         destroy: () => Promise<void>;
         repair?: IntegrationRepair;
-        conflictResolver?: ConflictResolver;
     }>;
     /**
      * The CREDENTIALED push, done by the Coordinator (control plane), NOT the sandbox (council#1). Takes the
@@ -177,8 +171,6 @@ export type MergeResult = {
         reason?: string;
     };
     repair?: RepairMeta;
-    conflictsResolved?: string[];
-    conflictResolverCostUsd?: number;
     terminal?: RepairTerminal;
     candidatePatch?: string;
 } | {
@@ -187,10 +179,10 @@ export type MergeResult = {
     phase: "no-workers" | "diff-out" | "provision" | "apply" | "test" | "push";
     quarantine?: string[];
     rej?: string;
+    conflict?: MergeConflict;
     retry?: boolean;
     details?: string;
     repair?: RepairMeta;
-    conflictResolverCostUsd?: number;
     terminal?: RepairTerminal;
     candidatePatch?: string;
     measure?: {
@@ -200,4 +192,21 @@ export type MergeResult = {
 };
 /** Integrate completed workers' branches. Never throws — failures are typed MergeResult. */
 export declare function mergeBranches(reports: WorkerReport[], baseSha: string, deps: MergeDeps): Promise<MergeResult>;
+/** 探测脚本里某一半失败时打到 stdout 的标记前缀(`grep` / `find` 各一);只由 {@link conflictFilesOf} 认。
+ *  ⚠️ 判序承重:`conflictFilesOf` **先**测本前缀、**后**剥 `./` —— `grep -rl` / `find .` 输出的真路径恒带 `./`,
+ *  所以一个真叫 `__PROBE_FAIL_grep` 的文件到达时是 `./__PROBE_FAIL_grep`,不与标记二义;把剥 `./` 挪到前面就静默破功。 */
+export declare const PROBE_FAIL_PREFIX = "__PROBE_FAIL_";
+/**
+ * S-113 / [ref] ④ — 把 `grep -rIl` + `find` 的输出变成**冲突路径清单**(给用户,不含内容)。
+ * 逐行:去掉 `./` 前缀、剥掉 `.rej` 后缀(`pkg/a.ts.rej` 与 `pkg/a.ts` 是同一处冲突的两种痕迹)、去重、
+ * 按 {@link CONFLICT_FILES_MAX} 封顶并**交回是否截断**(F5:静默封顶会让用户把 200 当成全部)。两条命令合成
+ * 一次 exec,所以 stdout 里两族路径混在一起 —— 本函数是它唯一的解释者。任一半探测失败 ⇒ 那一半打出
+ * {@link PROBE_FAIL_PREFIX} 标记、另一半的清单照常回来 ⇒ `probeFailed` 点名失败的那半、`files` 只是**不完整**而不是
+ * 「没有冲突」:`conflict` 段仍在场(用户仍拿得到分支与冲突者身份),调用点另记一行响亮日志(合并复审 车HB H-7)。
+ */
+export declare function conflictFilesOf(stdout: string): {
+    files: string[];
+    truncated: boolean;
+    probeFailed: string[];
+};
 //# sourceMappingURL=merge.d.ts.map

package/dist/leader/merge.js

@@ -1,7 +1,9 @@
 import { delimitUntrusted } from "@sema-agent/core";
-import { OVERSIZED_DIAG_PLACEHOLDER, redactErrorMessage, redactHead, redactTail } from "../observability/run-terminal-log.js";
+import { OVERSIZED_DIAG_PLACEHOLDER, redactArtifactText, redactErrorMessage, redactHead, redactTail } from "../observability/run-terminal-log.js";
 import { applyAndGrade, changedFilesOutOfAllowlist } from "./grader-env-factory.js";
 import { shellQuote as Q } from "../plugins/remote-shell.js";
+const CONFLICT_FILES_MAX = 200;
+const CONFLICT_REJ_HEAD_MAX = 2048;
 export async function mergeBranches(reports, baseSha, deps) {
     const repo = deps.repoDir ?? "/repo";
     const mergeable = reports.filter((r) => r.status === "completed");
@@ -10,7 +12,6 @@ export async function mergeBranches(reports, baseSha, deps) {
     }
     let destroy;
     let phase = "diff-out";
-    let conflictResolverCostUsd = 0;
     let repairMeta;
     let measure;
     try {
@@ -28,23 +29,29 @@ export async function mergeBranches(reports, baseSha, deps) {
         const { env } = integ;
         const integBase = (await env.exec("git rev-parse HEAD", { cwd: repo })).stdout.trim();
         phase = "apply";
-        const conflictsResolved = [];
+        const applied = [];
         for (const p of patches) {
             const patchPath = `/tmp/${p.workerId}.patch`;
             await env.writeFile(patchPath, p.patch);
             const ap = await env.exec(`git apply --3way --whitespace=nowarn ${Q(patchPath)}`, { cwd: repo });
             if (ap.exitCode !== 0) {
                 const rej = await env.exec(`find . -name '*.rej' -print -exec cat {} +`, { cwd: repo }).catch(() => ({ stdout: "", stderr: "", exitCode: -1 }));
-                const cr = integ.conflictResolver && integ.conflictResolver.maxRounds > 0
-                    ? await resolveApplyConflict(env, repo, p, rej.stdout, ap.stderr, integ.conflictResolver, deps)
-                    : { resolved: false, costUsd: 0 };
-                conflictResolverCostUsd += cr.costUsd;
-                if (!cr.resolved) {
-                    deps.logger?.warn?.("merge_apply_failed", { workerId: p.workerId, exitCode: ap.exitCode });
-                    return { ok: false, phase: "apply", reason: `git apply --3way failed for ${p.workerId} (conflict)`, quarantine: [p.workerId], rej: rej.stdout, details: redactHead(ap.stderr, 800), ...(conflictResolverCostUsd > 0 ? { conflictResolverCostUsd } : {}) };
-                }
-                conflictsResolved.push(p.workerId);
+                const listing = await env
+                    .exec(`grep -rIlE --exclude-dir=.git '^(<<<<<<<|>>>>>>>)' . 2>/dev/null; [ $? -le 1 ] || echo ${PROBE_FAIL_PREFIX}grep; ` +
+                    `find . -path ./.git -prune -o -name '*.rej' -print 2>/dev/null || echo ${PROBE_FAIL_PREFIX}find`, { cwd: repo })
+                    .catch(() => ({ exitCode: -1, stdout: "", stderr: "" }));
+                const { files, truncated, probeFailed } = conflictFilesOf(listing.stdout);
+                if (listing.exitCode !== 0 || probeFailed.length > 0)
+                    deps.logger?.warn?.("merge_conflict_files_probe_failed", { workerId: p.workerId, exitCode: listing.exitCode, probeFailed });
+                deps.logger?.warn?.("merge_apply_failed", { workerId: p.workerId, exitCode: ap.exitCode, files: files.slice(0, 20) });
+                const rejHead = redactArtifactText(rej.stdout).slice(0, CONFLICT_REJ_HEAD_MAX);
+                return {
+                    ok: false, phase: "apply", reason: `git apply --3way failed for ${p.workerId} (conflict)`,
+                    quarantine: [p.workerId], rej: rej.stdout, details: redactHead(ap.stderr, 800),
+                    conflict: { files, ...(truncated ? { filesTruncated: true } : {}), applied: [...applied], conflicted: p.workerId, ...(rejHead ? { rejHead } : {}) },
+                };
             }
+            applied.push(p.workerId);
         }
         phase = "test";
         let test = await env.exec(deps.testCmd, { cwd: repo });
@@ -74,7 +81,7 @@ export async function mergeBranches(reports, baseSha, deps) {
             deps.logger?.info?.("integration_repair_done", { ...repairMeta });
         }
         if (test.exitCode !== 0) {
-            return { ok: false, phase: "test", reason: `integration test failed (exit ${test.exitCode})`, details: redactTail(test.stdout + "\n" + test.stderr, 2000), ...(repairMeta ? { repair: repairMeta } : {}), ...(conflictResolverCostUsd > 0 ? { conflictResolverCostUsd } : {}) };
+            return { ok: false, phase: "test", reason: `integration test failed (exit ${test.exitCode})`, details: redactTail(test.stdout + "\n" + test.stderr, 2000), ...(repairMeta ? { repair: repairMeta } : {}) };
         }
         if (deps.measureCmd) {
             const mr = await env.exec(deps.measureCmd, { cwd: repo });
@@ -83,7 +90,7 @@ export async function mergeBranches(reports, baseSha, deps) {
         phase = "push";
         if (repairMeta)
             await env.exec(`git reset --soft ${Q(integBase)}`, { cwd: repo });
-        const costTail = { ...(repairMeta ? { repair: repairMeta } : {}), ...(conflictResolverCostUsd > 0 ? { conflictResolverCostUsd } : {}) };
+        const costTail = { ...(repairMeta ? { repair: repairMeta } : {}) };
         const commit = await env.exec(`git add -A && git -c user.email=leader@local -c user.name=leader commit -m ${Q(`merge: integrate ${mergeable.map((r) => r.workerId).join("+")}`)} --allow-empty`, { cwd: repo });
         if (commit.exitCode !== 0) {
             return { ok: false, phase: "push", reason: `failed to create integration commit (exit ${commit.exitCode})`, details: redactHead(commit.stdout + "\n" + commit.stderr, 800), ...costTail };
@@ -107,7 +114,6 @@ export async function mergeBranches(reports, baseSha, deps) {
                 candidatePatch: h.candidatePatch,
                 ...(measure ? { measure } : {}),
                 ...(repairMeta ? { repair: repairMeta } : {}),
-                ...(conflictResolverCostUsd > 0 ? { conflictResolverCostUsd } : {}),
             };
         }
         const push = await deps.push(integrated.stdout, baseSha);
@@ -117,7 +123,7 @@ export async function mergeBranches(reports, baseSha, deps) {
             return { ok: false, phase: "push", reason: `push failed: ${push.error}`, ...costTail };
         }
         deps.logger?.info?.("merge_ok", { ref: push.ref, merged: mergeable.map((r) => r.workerId), ...(repairMeta ? { repairRounds: repairMeta.rounds } : {}) });
-        return { ok: true, ref: push.ref, merged: mergeable.map((r) => r.workerId), ...(measure ? { measure } : {}), ...(repairMeta ? { repair: repairMeta } : {}), ...(conflictsResolved.length > 0 ? { conflictsResolved } : {}), ...(conflictResolverCostUsd > 0 ? { conflictResolverCostUsd } : {}) };
+        return { ok: true, ref: push.ref, merged: mergeable.map((r) => r.workerId), ...(measure ? { measure } : {}), ...(repairMeta ? { repair: repairMeta } : {}) };
     }
     catch (e) {
         return {
@@ -125,7 +131,6 @@ export async function mergeBranches(reports, baseSha, deps) {
             quarantine: mergeable.map((r) => r.workerId),
             ...(measure ? { measure } : {}),
             ...(repairMeta ? { repair: repairMeta } : {}),
-            ...(conflictResolverCostUsd > 0 ? { conflictResolverCostUsd } : {}),
         };
     }
     finally {
@@ -170,28 +175,30 @@ async function evaluatePushHold(mergeable, observeMeasure, integratedPatch, deps
     }
     return { measure };
 }
-async function resolveApplyConflict(env, repo, p, rejText, applyStderr, resolver, deps) {
-    let costUsd = 0;
-    const conflictText = `git apply --3way could not cleanly apply worker '${p.workerId}'.\n--- apply stderr ---\n${redactHead(applyStderr, 1500)}\n--- reject hunks (*.rej) ---\n${redactHead(rejText, 3000)}`;
-    for (let round = 0; round < resolver.maxRounds; round++) {
-        deps.logger?.warn?.("merge_conflict_repair_round", { workerId: p.workerId, round: round + 1, maxRounds: resolver.maxRounds });
-        try {
-            const r = await resolver.run({ round: round + 1, workerId: p.workerId, conflictText, patch: p.patch, repoDir: repo });
-            costUsd += r.costUsd ?? 0;
-        }
-        catch (e) {
-            deps.logger?.warn?.("merge_conflict_repair_error", { workerId: p.workerId, err: redactHead(e instanceof Error ? e.message : String(e), 2000) });
-            return { resolved: false, costUsd };
-        }
-        const check = await env
-            .exec(`grep -rIlE '^(<<<<<<<|>>>>>>>)' . 2>/dev/null; find . -name '*.rej' 2>/dev/null | head -20`, { cwd: repo })
-            .catch(() => ({ exitCode: -1, stdout: "DIRTY", stderr: "" }));
-        if (!check.stdout.trim()) {
-            await env.exec(`find . -name '*.orig' -delete 2>/dev/null || true`, { cwd: repo }).catch(() => { });
-            deps.logger?.info?.("merge_conflict_resolved", { workerId: p.workerId, rounds: round + 1 });
-            return { resolved: true, costUsd };
+export const PROBE_FAIL_PREFIX = "__PROBE_FAIL_";
+export function conflictFilesOf(stdout) {
+    const out = [];
+    const probeFailed = [];
+    const seen = new Set();
+    for (const raw of stdout.split("\n")) {
+        let f = raw.trim();
+        if (f === "")
+            continue;
+        if (f.startsWith(PROBE_FAIL_PREFIX)) {
+            probeFailed.push(f.slice(PROBE_FAIL_PREFIX.length));
+            continue;
         }
+        if (f.startsWith("./"))
+            f = f.slice(2);
+        if (f.endsWith(".rej"))
+            f = f.slice(0, -4);
+        if (f === "" || seen.has(f))
+            continue;
+        seen.add(f);
+        if (out.length >= CONFLICT_FILES_MAX)
+            return { files: out, truncated: true, probeFailed };
+        out.push(f);
     }
-    return { resolved: false, costUsd };
+    return { files: out, truncated: false, probeFailed };
 }
 //# sourceMappingURL=merge.js.map