@sema-agent/server 7.82.1 → 7.84.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/boot/resolve-spec.js

@@ -25,6 +25,7 @@ import { gateExecutionLane } from "../runtime-caps-resolver.js";
 import { applyRuntimeGovernance, stripDelegationTools } from "../runtime-governance.js";
 import { HttpError, encodeCheckpointScope } from "../security.js";
 import { memorySpecForRequest } from "../memory-scope.js";
+import { singleMemberOffFieldIssue } from "../request-value-closure.js";
 import { a2aForScenario, mcpForScenario } from "../config-center/facade.js";
 import { normalizeAttachments, normalizeResilience, normalizeResumeAtMode, normalizeSuggestNextPrompts, promptProfileFromBody, resolveTaskLimits, retainBackgroundProcessesFromBody, taskAgentsSpecFragment, toolMaterializeStrategyFromBody, toolNameListFromBody } from "../spec-fields.js";
 import { cwdHonored, deviceCwdHonored, effectiveHostWorkspace, inProcessSingleUserLane, isValidCwd, parseAdditionalDirectories, satisfiedByProcessCwd, shellEnvMismatchCount } from "../task-cwd.js";
@@ -36,6 +37,7 @@ import { redactSecrets } from "../trace/redact.js";
 import { DeferredSandboxPathEnv, isSandboxPathAdjudicationLane, sandboxPathEnvSlots } from "./deferred-sandbox-path-env.js";
 import { executionLaneHomeDir } from "../execution-lane-caps.js";
 import { effectiveMemoryPersistenceCapable } from "./memory-boundary.js";
+import { memoryFaceMounted } from "../memory-scope.js";
 export function createResolveSpec(ctx) {
     const { config, logger, metrics, localRoot, scenarios, principalCaps, centerRuntimeCapsResolver, getCenterPrompts, getKeyResolver, taskAttachmentStore, perSessionCwd, setSessionCwd, setSessionShellEnv, fenceSessionOwner, hookLlm, hookAgent, fleetBus, hookWakeBus, noteSessionShellGate, resumeAnchorStore, ownerAware, taskLimitCaps, taskTimeoutSec, selectEnvTool, sendUserFileToolSpec, memoryEngine, durableEnabled, approvalExemptionStore, singleUserAutoAcceptBaseline, checkpointStore, deploymentHooks, imageIndex, perTaskImage, sessionEnvSelection, liveQuestionFace, approverSeat, lockedKeys, } = ctx;
     assertGuardPatternsUsable(config);
@@ -59,9 +61,9 @@ export function createResolveSpec(ctx) {
                 throw new HttpError(400, `cwd "${conflict.cwd.asSpelled}" is inside this session's scratchpad "${conflict.scratchpadDir.asSpelled}" — the scratchpad is the fs-write gate's EXEMPT directory, so a task rooted there would auto-approve every write under its own root and the engine refuses to build the gate at all (config.write_exempt_dir_covers_root). Point cwd at the project directory instead (or send no cwd and let the session keep the one it has): this session registers the cwd you send, so a task that happens not to mount the write gate would still leave every LATER task on this session rooted in the exemption. A workflow that really is meant to write without prompts says so with a knob that means it (a permission mode, an open write face) and still keeps its root outside the scratchpad — those knobs do not lift this refusal, because the conflict is between two fields of this request, not a permission level.`, { code: "request.field_conflict", extra: { cwd: conflict.cwd, scratchpadDir: conflict.scratchpadDir } });
             }
         }
-        const rawMemoryCapture = body.memoryCapture;
-        if (rawMemoryCapture !== undefined && rawMemoryCapture !== "off") {
-            throw new HttpError(400, "memoryCapture must be the string 'off' when present (the session-level memory-capture opt-out declaration; absent = capture as usual — there is no 'on' spelling)", { code: "request.field_invalid" });
+        const offFieldIssue = singleMemberOffFieldIssue(body);
+        if (offFieldIssue) {
+            throw new HttpError(400, offFieldIssue.message, { code: "request.field_invalid" });
         }
         assertRequestA2aUnlocked(body.a2aPeers, lockedKeys);
         const gated = await gateScenarioAndAppend(body, auth, opts);
@@ -373,7 +375,9 @@ export function createResolveSpec(ctx) {
                 return { ...(Object.keys(merged).length > 0 ? { limits: merged } : {}), ...(declarations.length > 0 ? { configOverrides: declarations } : {}) };
             })(),
             ...(config.requirePrincipal !== true ? { backgroundScope: "session" } : {}),
-            memory: memoryEngine ? memorySpecForRequest(auth?.memoryScope, body.memoryWrite, s4DefaultScopes, { multiTenant: config.requirePrincipal === true }, body.memoryCapture) : undefined,
+            memory: memoryEngine
+                ? memorySpecForRequest(auth?.memoryScope, body.memoryWrite, s4DefaultScopes, { multiTenant: config.requirePrincipal === true }, { memory: body.memory, memoryCapture: body.memoryCapture })
+                : undefined,
             ...((v) => (v !== undefined ? { memoryPersistenceCapable: v } : {}))(effectiveMemoryPersistenceCapable(config)),
             tools: ((base) => {
                 const extra = [...(selectEnvTool ? [selectEnvTool] : []), ...(sendUserFileToolSpec ? [sendUserFileToolSpec] : [])];
@@ -533,7 +537,7 @@ export function createResolveSpec(ctx) {
             governed = { ...governed, tools: stripDelegationTools(governed.tools) };
         }
         if (shouldDiscloseNoPersistentMemory({
-            memory: governed.memory,
+            memoryFaceMounted: memoryFaceMounted(governed.memory),
             declaredCapable: effectiveMemoryPersistenceCapable(config),
             hands: gated.hands,
             handsReadOnly: governed.handsReadOnly === true,

package/dist/capabilities/memory-notice.d.ts

@@ -18,7 +18,7 @@
  *    roster 把落盘路**整批**卸掉时,手带在场也等于没有写通道),但负控仍然成立:必须**全部**已知落盘路
  *    都不在才算断链 —— `excludeTools:["Write"]` 不算(Bash/Edit 还在),请求面摘一个工具名改不动结论。
  */
-import { type PromptProvider, type TaskSpec } from "@sema-agent/core";
+import { type PromptProvider } from "@sema-agent/core";
 import type { ScenarioHands } from "./hands-lane.js";
 /**
  * 「已知落盘路」的工具名闭集 —— 与 core 的 `rosterCanPersist` 同口径:**文件写工具**(Write/Edit/
@@ -35,9 +35,11 @@ export declare const KNOWN_PERSISTENCE_TOOL_NAMES: readonly ["Write", "Edit", "N
 export declare const NO_PERSISTENT_MEMORY_SECTION_ID = "sema/memory.no-persistent";
 /** 判别式的全部输入 —— 每一位都是**部署/装配期事实**,没有一位来自请求体的自我表态。 */
 export interface MemoryFaceFacts {
-    /** 本次任务最终的 `TaskSpec.memory`。`undefined` = 这一腿根本没有引擎记忆面(引擎未接、多租户 dark、
-     *  remote lane 平面分裂 fail-closed……三条路殊途同归:core 不会 prepare 记忆,也就不会挂任何披露)。 */
-    memory: TaskSpec["memory"];
+    /** 这一腿挂不挂记忆面 —— 由唯一属主 `memory-scope.ts` `memoryFaceMounted(spec.memory)` 算出(与 core `prepareMemory`
+     *  同判:`normalizeMemorySpec(...)?.enabled === true`)。`false` = 引擎未接 / 多租户 dark / remote lane fail-closed /
+     *  S-405 `memory:"off"`(键在场但 `enabled:false`)—— 殊途同归:core 不会 prepare 记忆,也就不会挂任何披露。
+     *  🔴 不再收 `TaskSpec.memory` 本体:按「键在不在场」判是 7.84.0 前的病(合并复审 车HF F1)。 */
+    memoryFaceMounted: boolean;
     /** 部署声明 `MEMORY_PERSISTENCE_CAPABLE`(三态)。`true` = operator 自证有推断看不见的持久通道
      *  (自定义 writer / MCP 记忆服务)⇒ 披露会变成假话,撤回;`false` = 强制披露;缺席 ⇒ 走推断。 */
     declaredCapable: boolean | undefined;

package/dist/capabilities/memory-notice.js

@@ -9,7 +9,7 @@ function anyPersistenceToolSurvives(excludeTools) {
     return KNOWN_PERSISTENCE_TOOL_NAMES.some((name) => !excluded.has(name));
 }
 export function shouldDiscloseNoPersistentMemory(facts) {
-    if (facts.memory !== undefined)
+    if (facts.memoryFaceMounted)
         return false;
     if (facts.declaredCapable !== undefined)
         return !facts.declaredCapable;

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/http/admission.js

@@ -3,6 +3,7 @@ import { isModelAllowlisted, matchCatalogModel } from "../model-select.js";
 import { HttpError } from "../security.js";
 import { MAX_SETTINGS_OUTPUT_STYLE_CHARS, MAX_SETTINGS_PERMISSION_RULES, MAX_SETTINGS_ENV_VARS, MAX_SETTINGS_ENV_KEY_CHARS, MAX_SETTINGS_ENV_VALUE_CHARS, parseTaskSettings, skillListingBudgetFractionOk, skillListingMaxDescOk, taskSettingsKeyIssue } from "../task-settings.js";
 import { taskBodyKeyIssue } from "../request-key-closure.js";
+import { singleMemberOffFieldIssue } from "../request-value-closure.js";
 import { selfOrchestrationDenial } from "../task-workflow.js";
 import { centerEntitlementSourceWired } from "../runtime-caps-resolver.js";
 import { parseHooksConfig } from "../hooks/hook-runner.js";
@@ -307,9 +308,12 @@ export function createAdmission(ctx) {
             sendError(res, 400, "request.field_invalid", "memoryWrite must be a boolean (false = pause memory writes for this run)");
             return null;
         }
-        if (body.memoryCapture !== undefined && body.memoryCapture !== "off") {
-            sendError(res, 400, "request.field_invalid", "memoryCapture must be the string 'off' when present (the session-level memory-capture opt-out declaration; absent = capture as usual — there is no 'on' spelling)");
-            return null;
+        {
+            const offFieldIssue = singleMemberOffFieldIssue(body);
+            if (offFieldIssue) {
+                sendError(res, 400, "request.field_invalid", offFieldIssue.message);
+                return null;
+            }
         }
         if (body.requireExistingSession !== undefined && typeof body.requireExistingSession !== "boolean") {
             sendError(res, 400, "request.field_invalid", "requireExistingSession must be a boolean");

package/dist/http/wire-types.d.ts

@@ -320,6 +320,28 @@ export interface TaskRequestBody {
      *  记忆面暗的部署(引擎未接线 / 多租户)上本键随 `memory` 整体缺席而无处落 —— 那里本就零采集。
      *  Rides the persisted body onto resume legs(与 memoryWrite 同姿势)。 */
     memoryCapture?: "off";
+    /** core [ref] r5 §5 W3(server S-405):**请求级「记忆整面关」声明** —— `"off"` = 这一次运行**不挂记忆面**
+     *  (没有 `# Memory` 段/索引/三只记忆工具/写准入)。单成员闭集,**没有** `"on"`(缺席就是记忆照常挂的唯一形;
+     *  声明只能单向收紧)。透传为 `TaskSpec.memory.enabled:false` —— ⚠️ **保留事实,不折成整键缺席**:core 的
+     *  终局观测面把「有 spec 但被关」读作 `reason:"disabled"`、把「没有 spec」读作 `reason:"no-spec"`,审计上
+     *  不是一件事,所以本仓铸的是 `{ …正常 scopes, enabled:false }`。
+     *  ⚠️ **语义如实**:这是「不挂记忆面」,**不是**文件系统级的禁读禁写 —— 记忆根若落在本次授权的工作区内,
+     *  普通 Read/Write 照走普通围栏(没有记忆面 = 没有记忆写门,不是多了一道禁令)。
+     *  与 `memoryCapture:"off"` **不是一个轴**:那是「记忆照常挂,但本会话的内容永远不进长期记忆」
+     *  (采集面,落一条单向会话记录);这是「本次运行整个记忆面都不挂」(读写整面,逐请求)。
+     *  🔴 **两键同发时不要以为买到了两件事**(亲核 core 7.21.1 `prepare-memory.js:48/:55`):core 把 capture 腿与
+     *  引擎挂载合取,`enabled:false` 下 capture 的**单向会话记录不落**(core 发 `phase:"config"` 一行披露)⇒
+     *  下一 turn 不带本键时采集照常。要「这个会话永久别记」,那一 turn 就**别**同时发本键。详见契约 §12.7。
+     *  与 `memoryWrite:false`(本 run 只读平面:照常挂、照常读、harvest 不提交)同样正交、同样可并存。
+     *  🔴 **与 `GET /v1/capabilities` 的 legacy 能力位 `memory`(恒假)同名不同物**:那一位说的是退役的
+     *  MemoryStore HTTP 动词族,与本键零关系 —— 别按那一位判断本键可不可用。
+     *  ⚠️ 拼写门**两腿同判、响亮拒**:fresh 400 `request.field_invalid`;resume 重放同判(不做 resume 降级 ——
+     *  把一条收紧声明按打字错误静默丢掉是不可逆方向的静默降级)。两腿共用同一只判据
+     *  (`request-value-closure.ts` 的 `singleMemberOffFieldIssue`,与 `memoryCapture` 同表)。
+     *  记忆面暗的部署(引擎未接线 / 多租户)上 `memory` 整键本就缺席,本声明无处落也无事可关。
+     *  Rides the persisted body onto resume legs(与 `memoryWrite` 同姿势)。
+     *  ⏳ 子代地板(`ParentSpecSeat.memoryOff`:父关 ⇒ 子代/孙代同关)候 core 7.22.0,**本版不做**。 */
+    memory?: "off";
     /** 142-S4 projectId 线程化([ref] §2):这个 run 归属的项目(center 登记簿键,generic lowercase
      *  UUID — core S1 `resolveProjectId` marker 或 S3 无仓 mint 的产物;客户端只透传,零铸造权威)。是「哪个
      *  项目」的选择器,不是身份/capability — scope 的 tenant 段永远来自 verified principal。SHAPE 门在

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