oasis_test_v2 2.2.89 → 2.2.90

package/dist/index.js

@@ -707,7 +707,10 @@ function isDispatchUndecidable(error2) {
 function isDispatchFenced(error2) {
   return typeof error2 === "object" && error2 !== null && error2.dispatchFenced === true;
 }
-var SeqConflictError, BlobNotFoundError, AssistantBindConflictError, TraceSeqConflictError, DispatchUndecidableError, DispatchFencedError;
+function isCompanyMembersLockLost(error2) {
+  return typeof error2 === "object" && error2 !== null && error2.companyMembersLockLost === true;
+}
+var SeqConflictError, BlobNotFoundError, AssistantBindConflictError, TraceSeqConflictError, DispatchUndecidableError, DispatchFencedError, CompanyMembersLockLostError;
 var init_errors = __esm({
   "../contract/src/errors.ts"() {
     "use strict";
@@ -771,6 +774,19 @@ var init_errors = __esm({
       /** 结构化标记，理由同 {@link DispatchUndecidableError.dispatchUndecidable}。 */
       dispatchFenced = true;
     };
+    CompanyMembersLockLostError = class extends Error {
+      constructor(companyId, reason, writeIssued = false) {
+        super(
+          `company members lock lost for ${companyId} (${reason}); ` + (writeIssued ? "the external write was already in flight and its outcome is undetermined" : "the pending external write was not issued")
+        );
+        this.companyId = companyId;
+        this.reason = reason;
+        this.writeIssued = writeIssued;
+      }
+      name = "CompanyMembersLockLostError";
+      /** 结构化标记，理由同 {@link DispatchUndecidableError.dispatchUndecidable}（跨包不靠 instanceof）。 */
+      companyMembersLockLost = true;
+    };
   }
 });
 
@@ -127579,7 +127595,9 @@ function scan(state, ctx) {
           workorderId: state.workorder.id,
           nodeId: node2.id,
           workId: lw.id,
-          reason: "failed exhausted"
+          reason: ENGINE_RETRY_FUSE_KILL_REASON,
+          source: "sla"
+          // ADR 0626：引擎连败熔断 = 系统停的（节点主状态「待处理」，上报关掉也不掉成「已暂停」）
         });
         const retryEscId = `esc:retry-exhausted:${lw.id}`;
         const stuckActor = node2.assigneeActorId;
@@ -128154,7 +128172,9 @@ function processReviews(state, nodeId, workId, ctx, events) {
             kind: "review.kill",
             workorderId: state.workorder.id,
             reviewId: lrId,
-            reason: "exhausted"
+            reason: "exhausted",
+            source: "sla"
+            // ADR 0626：评审熔断 = 系统停的
           });
           pushReviewExhaustedEscalation(state, nodeId, workId, lrId, req.reviewerActorId, exhausted.rounds, events);
         }
@@ -128348,7 +128368,7 @@ function assessConvergence(state, ctx) {
   const anyUnfinished = state.liveNodes().some((n) => !n.latestAcceptId);
   return { stuck: !anyRunning && !anyBlockingIssue && allIdle && anyUnfinished, codes };
 }
-var SYSTEM_ENGINE_ACTOR;
+var ENGINE_RETRY_FUSE_KILL_REASON, SYSTEM_ENGINE_ACTOR;
 var init_activate = __esm({
   "../engine/src/activate.ts"() {
     "use strict";
@@ -128363,6 +128383,7 @@ var init_activate = __esm({
     init_model();
     init_views2();
     init_kill();
+    ENGINE_RETRY_FUSE_KILL_REASON = "failed exhausted";
     SYSTEM_ENGINE_ACTOR = ENGINE_SYSTEM_ACTOR;
   }
 });
@@ -129041,6 +129062,9 @@ ALTER TABLE ${q2}.works   ADD COLUMN IF NOT EXISTS handled_issue_ids jsonb;
 ALTER TABLE ${q2}.works   ADD COLUMN IF NOT EXISTS protocol_recovery jsonb;
 -- ADR 0607\uFF1A\u6267\u884C\u4EBA\u786E\u8BA4\u300C\u4E0A\u6E38\u6362\u7248\u4E0D\u5F71\u54CD\u5DF2\u63A5\u53D7\u7684\u4EA4\u4ED8\u300D\uFF08note / \u786E\u8BA4\u4EBA / \u65F6\u523B / \u5F53\u65F6\u7684\u5DF2\u63A5\u53D7\u4EA4\u4ED8\uFF09\u3002
 ALTER TABLE ${q2}.works   ADD COLUMN IF NOT EXISTS upstream_ack jsonb;
+-- ADR 0626\uFF1Awork.kill / review.kill \u58F0\u660E\u7684\u300C\u8C01\u505C\u7684\u300D\uFF08human / manager / sla\uFF09\u3002\u5B58\u91CF\u884C\u4E3A NULL = \u672A\u58F0\u660E\u3002
+ALTER TABLE ${q2}.works   ADD COLUMN IF NOT EXISTS kill_source text;
+ALTER TABLE ${q2}.reviews ADD COLUMN IF NOT EXISTS kill_source text;
 -- \u56DE\u4FE1\u8F6E\u6307\u5411\u54EA\u6761 comment issue\uFF08\u7EAF\u6570\u636E\uFF09
 ALTER TABLE ${q2}.works   ADD COLUMN IF NOT EXISTS reply_to_issue_id text;
 -- \u2605 work lane\uFF08\u6B63\u5411\u5224\u636E\uFF0C\u53D6\u4EE3 "reply_to_issue_id IS NULL"\uFF09\uFF1A\u5B58\u91CF\u884C\u6309\u6709\u65E0 reply_to_issue_id \u56DE\u586B\u3002
@@ -134789,7 +134813,9 @@ var init_store_postgres = __esm({
             acceptedBy: w2.accepted_by,
             rejectedReason: w2.rejected_reason,
             overrideBy: w2.override_by,
-            overrideReason: w2.override_reason
+            overrideReason: w2.override_reason,
+            // 可选位：只在真有值时带上，与内存态 / 重放出来的行同形（未被停的行没有这个键）
+            ...w2.kill_source ? { killSource: w2.kill_source } : {}
           })),
           artifacts: arts.rows.map((a) => ({
             id: a.id,
@@ -134869,7 +134895,8 @@ var init_store_postgres = __esm({
             verdict: v2.verdict,
             note: v2.note,
             handActorId: v2.hand_actor_id,
-            decidedAt: iso(v2.decided_at)
+            decidedAt: iso(v2.decided_at),
+            ...v2.kill_source ? { killSource: v2.kill_source } : {}
           }))
         };
       }
@@ -135422,7 +135449,7 @@ var init_plan = __esm({
         const titleChanged = e.title !== void 0 && e.title !== node2.title;
         if (!specChanged && !titleChanged) return;
         state.updateNode(e.nodeId, {
-          ...specChanged ? { spec: e.spec, version: node2.version + 1 } : {},
+          ...specChanged ? { spec: e.spec, ...e.contentSync ? {} : { version: node2.version + 1 } } : {},
           ...titleChanged ? { title: e.title } : {},
           updatedAt: ctx.at
         });
@@ -135969,17 +135996,18 @@ var init_work = __esm({
         const target = e.workId ? state.work(e.workId) : null;
         const targetKillable = target !== null && target !== void 0 && (isWorkKillable(target) || target.endedAt !== null && target.endedAt !== void 0 && !target.deadAt && state.node(target.nodeId)?.latestAcceptId !== target.id);
         if (lw) {
-          if (isWorkKillable(lw)) {
-            killWorkRow(state, lw, ctx.at);
-          } else if (!lw.deadAt && lw.endedAt && node2.latestAcceptId !== lw.id) {
+          const lwKillable = isWorkKillable(lw) || !lw.deadAt && !!lw.endedAt && node2.latestAcceptId !== lw.id;
+          if (lwKillable) {
             killWorkRow(state, lw, ctx.at);
+            if (e.source) state.updateWork(lw.id, { killSource: e.source });
           }
         }
         if (targetKillable) {
           const w2 = state.work(e.workId);
           state.updateWork(e.workId, {
             ...w2.rejectedReason === null ? { rejectedReason: e.reason } : {},
-            ...w2.status !== "dead" ? { status: "dead" } : {}
+            ...w2.status !== "dead" ? { status: "dead" } : {},
+            ...e.source ? { killSource: e.source } : {}
           });
         }
         if (node2.latestProposedWorkId) {
@@ -136523,7 +136551,10 @@ var init_review = __esm({
       name: "review/kill",
       kind: "review.kill",
       apply(e, state, ctx) {
+        const before = state.review(e.reviewId);
+        const killable = !!before && isReviewKillable(before);
         killReview(state, e.reviewId, ctx.at);
+        if (killable && e.source) state.updateReview(e.reviewId, { killSource: e.source });
       },
       async effect(e, ctx) {
         await ctx.cancelSession(e.reviewId);
@@ -138141,8 +138172,11 @@ function emptyReadModel() {
     escalations: /* @__PURE__ */ new Map(),
     pendingReviews: /* @__PURE__ */ new Map(),
     pausedWorkorders: /* @__PURE__ */ new Set(),
-    acceptBlockers: /* @__PURE__ */ new Map()
+    creationHeldWorkorders: /* @__PURE__ */ new Set(),
+    acceptBlockers: /* @__PURE__ */ new Map(),
     // 默认空 = 无挡板 = 历史行为；只有 bridge 从引擎快照刷新时才填
+    reworkHalted: /* @__PURE__ */ new Map()
+    // 同上：只有 bridge 从引擎快照刷新时才填
   };
 }
 function indexAdd(index2, key2, value2) {
@@ -144085,6 +144119,25 @@ var init_command_card_naming = __esm({
   }
 });
 
+// ../core/src/seed-content.ts
+function headerRootIdOf(arts) {
+  const roots = arts.filter((a) => a.inputs.length === 0);
+  if (roots.length <= 1) return roots[0]?.id;
+  const consumed = new Set(arts.flatMap((a) => a.inputs.map((e) => e.to)));
+  return (roots.find((a) => !consumed.has(a.id)) ?? roots[0])?.id;
+}
+function isSeedContentNode(arts, artifactId) {
+  const humanRoots = arts.filter((a) => a.inputs.length === 0 && isHumanActorId(a.owner));
+  if (!humanRoots.some((a) => a.id === artifactId)) return false;
+  return humanRoots.length === 1 || headerRootIdOf(arts) === artifactId;
+}
+var init_seed_content = __esm({
+  "../core/src/seed-content.ts"() {
+    "use strict";
+    init_src();
+  }
+});
+
 // ../core/src/queue-retirement.ts
 function isSettledProduction(w2) {
   if (w2.lane === "reply") return false;
@@ -144133,6 +144186,10 @@ var init_queue_retirement = __esm({
 });
 
 // ../core/src/bridge-readmodel.ts
+function stopSourceOfDeadWork(w2) {
+  if (w2.killSource) return w2.killSource;
+  return w2.rejectedReason === ENGINE_RETRY_FUSE_KILL_REASON ? "sla" : "human";
+}
 function mapWorkStateToRevisionState(w2, artifactCount) {
   const s2 = workState(w2, w2.conclusion !== null && w2.conclusion !== void 0 || artifactCount > 0);
   switch (s2) {
@@ -144144,7 +144201,9 @@ function mapWorkStateToRevisionState(w2, artifactCount) {
     case "success":
       if (w2.acceptanceState === "accepted") return "merged";
       if (w2.acceptanceState === "rejected") return "rejected";
-      if (w2.conclusion == null) return "working";
+      if (w2.conclusion == null) {
+        return artifactCount > 0 ? "working" : "superseded";
+      }
       return "proposed";
     // 已 conclude、未裁决
     // ★ ADR 0148：failed 尝试没有对应的 RevisionState（枚举只有 working/proposed/merged/rejected/
@@ -144157,6 +144216,9 @@ function mapWorkStateToRevisionState(w2, artifactCount) {
       return "superseded";
   }
 }
+function settledWithoutOutput(w2, artifactFiles) {
+  return w2.status === "success" && !w2.deadAt && w2.conclusion == null && (artifactFiles.get(w2.id)?.length ?? 0) === 0;
+}
 function mapIssueStateToAnnotationState(i) {
   if (i.resolvedAt === null) return "open";
   return i.resolution === "wontfix" ? "wontfix" : "resolved";
@@ -144413,25 +144475,41 @@ function bridgeLoadReadModel(input) {
   const requirementsByNode = groupRows(allRequirements, (r) => r.nodeId);
   const repliesByIssue = groupRows(allReplies, (r) => r.issueId);
   const reviewById = new Map(allReviews.map((r) => [r.id, r]));
+  const artifactFiles = /* @__PURE__ */ new Map();
+  for (const a of allArtifacts) {
+    const list2 = artifactFiles.get(a.workId) ?? [];
+    list2.push(a);
+    artifactFiles.set(a.workId, list2);
+  }
   const acceptBlockers = /* @__PURE__ */ new Map();
+  const reworkHalted = /* @__PURE__ */ new Map();
+  const upstreamAckedBy = /* @__PURE__ */ new Map();
   for (const snap of snapshots2) {
     let state = null;
     const snapshotWorks = new Map(snap.works.map((w2) => [w2.id, w2]));
     for (const node2 of snap.nodes) {
+      const accepted = node2.latestAcceptId ? snapshotWorks.get(node2.latestAcceptId) : void 0;
+      if (accepted && !node2.cancelledAt) {
+        const pins = new Set((edgesByTarget.get(node2.id) ?? []).filter((e) => e.kind === "data" && e.pinnedWorkId).map((e) => e.pinnedWorkId));
+        const used = inputsByWork.get(accepted.id) ?? [];
+        const inputsMoved = pins.size !== used.length || used.some((i) => !pins.has(i.upstreamWorkId));
+        if (inputsMoved) {
+          state ??= new WorkorderState(snap);
+          const ack = acceptedInputsCurrent(state, node2, accepted) ? snap.works.filter((w2) => w2.nodeId === node2.id && w2.status === "success" && w2.upstreamAck?.acceptedWorkId === accepted.id).at(-1) : void 0;
+          if (ack) upstreamAckedBy.set(node2.id, ack.id);
+        }
+      }
       if (!node2.latestWorkId || node2.latestAcceptId === node2.latestWorkId) continue;
       const lw = snapshotWorks.get(node2.latestWorkId);
       if (!lw || !lw.endedAt || lw.deadAt) continue;
+      if (settledWithoutOutput(lw, artifactFiles) && node2.latestProposedWorkId === node2.latestAcceptId) continue;
       state ??= new WorkorderState(snap);
       const block = acceptBlock(state, lw.id);
       if (block) acceptBlockers.set(node2.id, block);
+      const halted = gateRejectionsExhausted(state, node2.id, {});
+      if (halted) reworkHalted.set(node2.id, halted);
     }
   }
-  const artifactFiles = /* @__PURE__ */ new Map();
-  for (const a of allArtifacts) {
-    const list2 = artifactFiles.get(a.workId) ?? [];
-    list2.push(a);
-    artifactFiles.set(a.workId, list2);
-  }
   const artifacts = /* @__PURE__ */ new Map();
   const workById = /* @__PURE__ */ new Map();
   for (const w2 of allWorks) workById.set(w2.id, w2);
@@ -144449,7 +144527,7 @@ function bridgeLoadReadModel(input) {
       else uiSt = st;
       art.latestWorkState = uiSt;
       art.latestAccepted = node2.latestProposedWorkId !== null && node2.latestAcceptId === node2.latestProposedWorkId;
-      if ((st === "failed" || st === "dead") && node2.latestProposedWorkId) {
+      if ((st === "failed" || st === "dead" || settledWithoutOutput(lw, artifactFiles)) && node2.latestProposedWorkId) {
         art.currentRev = node2.latestProposedWorkId;
       }
     } else {
@@ -144600,6 +144678,7 @@ function bridgeLoadReadModel(input) {
       const reqs = requirementsByNode.get(node2.id) ?? [];
       if (reqs.length === 0) continue;
       let stoppedAt = null;
+      let stoppedBy = null;
       let deadGroups = 0;
       let liveGroups = 0;
       for (const g2 of new Set(reqs.map((r) => r.reviewGroup))) {
@@ -144612,14 +144691,20 @@ function bridgeLoadReadModel(input) {
         const st = reviewState(r);
         if (st === "dead") {
           deadGroups += 1;
-          if (r.cancelledAt && (stoppedAt === null || r.cancelledAt > stoppedAt)) stoppedAt = r.cancelledAt;
+          if (r.cancelledAt && (stoppedAt === null || r.cancelledAt > stoppedAt)) {
+            stoppedAt = r.cancelledAt;
+            stoppedBy = r.killSource ?? null;
+          }
         } else if (st !== "accept" && st !== "reject") {
           liveGroups += 1;
         }
       }
       if (deadGroups === 0 || liveGroups > 0 || stoppedAt === null) continue;
       holds.set(node2.id, {
-        source: "sla",
+        // ADR 0626：来源取 review.kill 声明的 source（最后停的那一组）。此前恒写 sla——人用 `oasis hold`
+        // 连带停掉的评审（D11：已暂停）与系统止损停的（待处理）因此分不开。未声明来源 = 人停的
+        // （停评审的系统路径——零产出保险丝 / 评审熔断 / 系统 hold——都已声明 sla）。
+        source: stoppedBy ?? "human",
         by: "",
         at: stoppedAt,
         reason: "\u8BC4\u5BA1\u5DF2\u505C\xB7\u5F85\u6062\u590D\uFF08\u4EA4\u4ED8\u7248\u4FDD\u7559\uFF0C\u6062\u590D\u540E\u7EE7\u7EED\u6295\u7968\uFF09"
@@ -144629,7 +144714,7 @@ function bridgeLoadReadModel(input) {
     if (node2.latestAcceptId === node2.latestWorkId) continue;
     const reason = lw.rejectedReason ?? (lw.outcome === "failed" ? "\u8FD0\u884C\u5931\u8D25\u5DF2\u505C\uFF08\u8FDE\u8D25/\u8D85\u65F6\uFF09" : "\u624B\u52A8\u505C\u6B62");
     holds.set(node2.id, {
-      source: "human",
+      source: stopSourceOfDeadWork(lw),
       by: "",
       at: lw.deadAt,
       reason
@@ -144708,9 +144793,13 @@ function bridgeLoadReadModel(input) {
   }
   const workspaceStructuralSeq = /* @__PURE__ */ new Map();
   const pausedWorkorders = /* @__PURE__ */ new Set();
+  const creationHeldWorkorders = /* @__PURE__ */ new Set();
   for (const snap of snapshots2) {
     workspaceStructuralSeq.set(snap.workorder.id, snap.workorder.structuralVersion);
     if (snap.workorder.dispatchPaused) pausedWorkorders.add(snap.workorder.id);
+    if (snap.workorder.dispatchPaused && snap.workorder.pausedReason === WORKORDER_HOLD_AT_CREATE_REASON) {
+      creationHeldWorkorders.add(snap.workorder.id);
+    }
   }
   const revisionsByArtifact = /* @__PURE__ */ new Map();
   for (const w2 of allWorks) {
@@ -144737,7 +144826,9 @@ function bridgeLoadReadModel(input) {
   for (const edge of allEdges) {
     if (!edge.pinnedWorkId) continue;
     const record9 = pinMeta.get(edge.toNodeId) ?? {};
-    record9[edge.fromNodeId] = { seq: 0, actor: "", via: "link" };
+    const ackWorkId = upstreamAckedBy.get(edge.toNodeId);
+    const ackWork = ackWorkId ? workById.get(ackWorkId) : void 0;
+    record9[edge.fromNodeId] = ackWork ? { seq: proposeSeq.get(ackWork.id) ?? 0, actor: ackWork.assigneeActorId, via: "bump", ack: true } : { seq: 0, actor: "", via: "link" };
     pinMeta.set(edge.toNodeId, record9);
   }
   const pendingReviews = /* @__PURE__ */ new Map();
@@ -144818,18 +144909,21 @@ function bridgeLoadReadModel(input) {
     holds,
     workspaceStructuralSeq,
     pausedWorkorders,
+    creationHeldWorkorders,
     lastOpAt,
     pinMeta,
     gaps,
     deliveredGapSolutions,
     escalations,
     pendingReviews,
-    acceptBlockers
+    acceptBlockers,
+    reworkHalted
   };
 }
 var init_bridge_readmodel = __esm({
   "../core/src/bridge-readmodel.ts"() {
     "use strict";
+    init_src();
     init_src6();
     init_queue_retirement();
   }
@@ -145254,6 +145348,9 @@ function previewIntervention(model, plan, config2) {
   };
   for (const id of touched) expand(id);
   const nonMonotonicOps = classifyNonMonotonic(plan.ops);
+  if (plan.ops.some((op) => op.action === "edit" && op.description !== void 0 && op.description !== (model.artifacts.get(op.artifactId)?.description ?? null) && isSeedContentNode([...model.artifacts.values()].filter((a) => a.workspace === model.artifacts.get(op.artifactId)?.workspace), op.artifactId))) {
+    nonMonotonicOps.push("edit-seed-content");
+  }
   const changeClass = violations.length > 0 || nonMonotonicOps.length > 0 ? "C" : "B";
   return {
     changeClass,
@@ -145295,6 +145392,7 @@ var init_preview_intervention = __esm({
     init_kernel();
     init_node_identity();
     init_governance();
+    init_seed_content();
     MAX_PREREQ_DEPTH = 8;
   }
 });
@@ -145407,6 +145505,7 @@ var init_kernel_bridge = __esm({
     init_preview_intervention();
     init_errors2();
     init_errors2();
+    init_seed_content();
     init_rejected_proposals();
     PENDING_ROLE_PREFIX2 = "pending:role:";
     PENDING_UNASSIGNED2 = "pending:unassigned";
@@ -145460,6 +145559,15 @@ var init_kernel_bridge = __esm({
        * 不接也不影响作废本身：台账的周期对账看到条目消失后仍会收口，只是说不出「是谁把上报关了」。
        */
       draftVoidedListeners = /* @__PURE__ */ new Set();
+      /**
+       * 内容柜（ADR 0625）：工单总纲「改描述 = 出一版新内容」要把正文写成 blob，内核本身不持有 blobs，
+       * 由装配方（serve 的公司引擎路由 / startOasisServer / 测试基座）注入同一家公司的字节柜。
+       * 没注入时改总纲描述直接报错，而不是退回「升版本等人重交」的老路——那条路正是 Bug 0265 的卡死形状。
+       */
+      contentStore = null;
+      useContentStore(store) {
+        this.contentStore = store;
+      }
       /** 作废扫描的重入闸：作废走的 {@link dropDraftCard} 不刷新模型，但仍要挡住并发刷新里的重复扫描。 */
       sweepingStaleDrafts = false;
       model;
@@ -146221,6 +146329,15 @@ var init_kernel_bridge = __esm({
       }
       // ── 里程碑 / 收尾 ──
       async conclude(args) {
+        const result = await this.concludeCore(args);
+        try {
+          await this.syncSeedSpec(args.artifactId, args.actor);
+        } catch (err) {
+          console.warn(`[kernel-bridge] \u603B\u7EB2 spec \u955C\u50CF\u540C\u6B65\u5931\u8D25\uFF08${args.artifactId}\uFF09\uFF1A${String(err)}`);
+        }
+        return result;
+      }
+      async concludeCore(args) {
         await this.refreshTracked();
         const wid = this.wo(args.artifactId);
         const conv = convergenceState(this.model, args.artifactId);
@@ -146311,6 +146428,72 @@ var init_kernel_bridge = __esm({
         }
         return { kind: "milestone", head: headId };
       }
+      /**
+       * 工单总纲出一版新内容（ADR 0625）：**出版本、收口、验收一步完成，改的人就是拍板的人**。
+       *
+       * 两个入口共用这一处：页头保存（`PUT /api/workorders/:id/overview`）与改图里对总纲的 `edit description`。
+       * - 内容与当前最新一版相同 → 不出新版（同值不 bump），只把 spec 镜像对齐；
+       * - 工单暂停 → 只记人工稿（`recordPausedRevision`，不开运行、不验收，恢复后由 scan 处理）；
+       * - 否则 propose → advanceQueue → conclude（与建单首版 `seedWorkorderBrief` 同一条链）。
+       * 下游只按「输入换版」各派一轮，可用 `oasis ack` 确认沿用（ADR 0607），不因此扩大级联。
+       */
+      async publishSeedContent(args) {
+        const store = this.contentStore;
+        if (!store) throw new KernelError("\u5185\u5BB9\u67DC\u672A\u88C5\u914D\uFF0C\u65E0\u6CD5\u4FDD\u5B58\u5DE5\u5355\u603B\u7EB2\u5185\u5BB9", "content-store-missing");
+        await this.refreshTracked();
+        const wid = this.wo(args.artifactId);
+        const snap = await this.store.transaction((tx) => tx.loadWorkorder(wid));
+        const paused = !!snap?.workorder.dispatchPaused;
+        const current = await this.seedContentText(snap, args.artifactId);
+        if (current !== null && current.trim() === args.text.trim()) {
+          await this.commitSeedSpec(args.artifactId, args.actor, current);
+          return { published: false, concluded: !paused };
+        }
+        const contentRef = await store.put(new TextEncoder().encode(args.text));
+        if (paused) {
+          await this.recordPausedRevision({ artifactId: args.artifactId, actor: args.actor, contentRef, note: args.note });
+          await this.commitSeedSpec(args.artifactId, args.actor, args.text);
+          return { published: true, concluded: false };
+        }
+        await this.proposeRevision({ artifactId: args.artifactId, actor: args.actor, contentRef, reason: args.note });
+        await this.advanceQueue(args.artifactId, args.actor);
+        const result = await this.conclude({ artifactId: args.artifactId, actor: args.actor, note: args.note });
+        await this.commitSeedSpec(args.artifactId, args.actor, args.text);
+        return { published: true, concluded: result.kind !== "gate-pending" };
+      }
+      /** 总纲最新一版有内容的正文（单个 inline 交付物）；取不到（无版本 / 装箱单 / 外链）→ null。 */
+      async seedContentText(snap, artifactId) {
+        const node2 = snap?.nodes.find((n) => n.id === artifactId);
+        const workId = node2?.latestProposedWorkId ?? node2?.latestAcceptId ?? null;
+        if (!workId || !this.contentStore) return null;
+        const outs = snap.artifacts.filter((a) => a.workId === workId);
+        if (outs.length !== 1 || outs[0].contentKind !== "inline") return null;
+        return new TextDecoder().decode(await this.contentStore.get(outs[0].contentRef));
+      }
+      /** 定稿后把总纲 spec 对齐到它最新一版的正文（只对总纲；非总纲、无内容柜、内容相同都 no-op）。 */
+      async syncSeedSpec(artifactId, actor) {
+        if (!this.contentStore) return;
+        const art = this.model.artifacts.get(artifactId);
+        if (!art) return;
+        const arts = [...this.model.artifacts.values()].filter((a) => a.workspace === art.workspace);
+        if (!isSeedContentNode(arts, artifactId)) return;
+        const snap = await this.store.transaction((tx) => tx.loadWorkorder(this.wo(artifactId)));
+        const text7 = await this.seedContentText(snap, artifactId);
+        if (text7 !== null) await this.commitSeedSpec(artifactId, actor, text7);
+      }
+      /** 发 `plan.update_spec{contentSync}`：只改 spec、不升版本（引擎侧语义见 handlers/plan.ts）。 */
+      async commitSeedSpec(artifactId, actor, text7) {
+        const wid = this.wo(artifactId);
+        const snap = await this.store.transaction((tx) => tx.loadWorkorder(wid));
+        const node2 = snap?.nodes.find((n) => n.id === artifactId);
+        if (!node2 || node2.spec === text7) return;
+        await this.commit({
+          companyId: "",
+          workorderId: wid,
+          actorId: actor,
+          event: { kind: "plan.update_spec", workorderId: wid, nodeId: artifactId, spec: text7, policy: "auto", contentSync: true }
+        });
+      }
       /** 「这个 work 是否有 runtime 会话负责回报 response」的权威判据（serve 注入 dispatchToWork 在途登记）。 */
       runtimeSessionAuthority = null;
       setRuntimeSessionAuthority(fn) {
@@ -146852,10 +147035,10 @@ var init_kernel_bridge = __esm({
        *  ① `issue.resolve` 的 handler 已经会对 gap/escalation 跑 `markNodeForRetry`（dead → retry），
        *     多数情况下节点就此复活——本方法只补它没覆盖的那一段：retry 之后 scan 因故没能建出新 work，
        *     `latest_work.deadAt` 还在 → 派生的 hold 仍然成立、节点继续冻着。
-       *  ② 派生的 hold **不带真实来源**：`bridge-readmodel` 的 holds 投影把 source 硬写成 `"human"`
-       *     （`kernel.hold` 只落 `work.kill`，`source` 参数根本没进存储）。所以这里**不能**按
-       *     `source === "sla"` 分档——那个判据恒不成立。改用「已无未解上报」当分寸：球不在任何人手里了，
-       *     才解冻。
+       *  ② 这里**不按** hold 的 source 分档，用「已无未解上报」当分寸：球不在任何人手里了，才解冻。
+       *     写这段时 source 根本没进存储（`bridge-readmodel` 硬写 `"human"`）；ADR 0626 起 `work.kill` /
+       *     `review.kill` 带 source 落 `kill_source`，但存量行仍没有这一列，而且解冻要不要做本来就该看
+       *     「还有没有人在等」，不看是谁停的——所以口径不变。
        */
       async releaseIfStillHeld(artifactId, actor) {
         await this.refreshModel();
@@ -146927,7 +147110,7 @@ var init_kernel_bridge = __esm({
               companyId: "",
               workorderId: wid,
               actorId: args.actor,
-              event: { kind: "review.kill", workorderId: wid, reviewId: r.id, reason }
+              event: { kind: "review.kill", workorderId: wid, reviewId: r.id, reason, ...args.source ? { source: args.source } : {} }
             });
           }
           return { kind: "reviews-stopped", workId: headWork.id, reviewIds: killable.map((r) => r.id) };
@@ -146946,7 +147129,9 @@ var init_kernel_bridge = __esm({
             workorderId: wid,
             nodeId: args.artifactId,
             workId: latestWork.id,
-            reason
+            reason,
+            // ADR 0626：把「谁停的」落进事实——读面的 hold.source 从这里取（此前在这里被丢掉，桥一律记成 human）。
+            ...args.source ? { source: args.source } : {}
           }
         });
         return { kind: "work-killed", workId: latestWork.id };
@@ -147026,7 +147211,7 @@ var init_kernel_bridge = __esm({
             companyId: "",
             workorderId: wid,
             actorId: args.actor,
-            event: { kind: "review.kill", workorderId: wid, reviewId: r.id, reason: args.reason ?? "\u624B\u52A8\u505C\u6B62\u8BC4\u5BA1" }
+            event: { kind: "review.kill", workorderId: wid, reviewId: r.id, reason: args.reason ?? "\u624B\u52A8\u505C\u6B62\u8BC4\u5BA1", ...args.source ? { source: args.source } : {} }
           });
           killed.push(r.id);
         }
@@ -147567,6 +147752,8 @@ var init_kernel_bridge = __esm({
           events.push(input);
         };
         const enqueue = async (event) => queue({ companyId: "", workorderId: event.workorderId, actorId: _actor, event });
+        const seedContentEdits = /* @__PURE__ */ new Map();
+        const scopedArtifactsOf = (workspace) => [...this.model.artifacts.values()].filter((a) => a.workspace === workspace);
         for (const op of plan.ops) {
           switch (op.action) {
             case "spawn": {
@@ -147715,6 +147902,8 @@ var init_kernel_bridge = __esm({
               }
               const opTitle = op.title;
               const opDescription = op.description;
+              const seedEdit = artId && opDescription !== void 0 && opDescription !== (artifacts.get(artId)?.description ?? null) && isSeedContentNode(scopedArtifactsOf(woFor(artId)), artId);
+              if (seedEdit) seedContentEdits.set(artId, opDescription);
               if (artId && (opTitle !== void 0 || opDescription !== void 0)) {
                 await queue({
                   companyId: "",
@@ -147726,7 +147915,8 @@ var init_kernel_bridge = __esm({
                     nodeId: artId,
                     spec: opDescription ?? artifacts.get(artId)?.description ?? null,
                     ...opTitle !== void 0 ? { title: opTitle } : {},
-                    policy: "auto"
+                    policy: "auto",
+                    ...seedContentEdits.has(artId) ? { contentSync: true } : {}
                   }
                 });
               }
@@ -147798,6 +147988,9 @@ var init_kernel_bridge = __esm({
           }
         });
         if (unsupported.length) throw new KernelError(`\u6574\u6279\u672A\u843D\u5730\uFF1B\u4EE5\u4E0B op \u672C\u5F15\u64CE\u4E0D\u652F\u6301\uFF1A${unsupported.join("\u3001")}`, "unsupported-op");
+        for (const [artifactId, text7] of seedContentEdits) {
+          await this.publishSeedContent({ artifactId, actor: _actor, text: text7, note: plan.reason?.trim() || "\u7F16\u8F91\u5DE5\u5355\u63CF\u8FF0" });
+        }
         await this.ensureWorkorder(wid, "", _actor);
         await this.bus.submitBatchAndProcess(events);
         for (const event of events) {
@@ -147848,6 +148041,7 @@ var init_src7 = __esm({
     init_session_limits();
     init_rejected_proposals();
     init_command_card_naming();
+    init_seed_content();
     init_kernel_bridge();
     init_bridge_readmodel();
     init_queue_retirement();
@@ -148066,17 +148260,26 @@ function workorderClosure(members) {
 function deriveStage(members, opts) {
   const closure = workorderClosure(members.map((m2) => m2.info));
   if (closure === "cancelled") return "cancelled";
-  if (members.some((m2) => m2.state === "pending")) return "pending";
+  if (opts?.awaitingDispatch) return "awaiting_dispatch";
   if (opts?.dispatchPaused) return "held";
-  if (members.some((m2) => m2.state === "blocked")) return "blocked";
+  if (members.some((m2) => m2.state === "pending")) return "pending";
+  const advancing = members.some(
+    (m2) => m2.state === "running" || m2.state === "queued" || m2.state === "reviewing" || m2.state === "blocked" && m2.blockedBy === "gap"
+  );
+  if (!advancing && members.some((m2) => m2.state === "held")) return "held";
+  if (members.some((m2) => m2.state === "blocked" && m2.blockedBy !== "upstream")) return "blocked";
   if (closure === "settled" || closure === "archived") return "concluded";
   const delivery = members.filter((m2) => !m2.overviewRoot && !m2.info.sealed);
   if (delivery.length > 0 && delivery.every((m2) => m2.state === "not_run")) return "not_started";
   return "executing";
 }
 function nodeRunState(model, artifact, info, runtime, opts) {
-  if (info.sealed) return void 0;
-  if (artifact.continuationPause) return artifact.continuationPause.decision === "pending" ? "pending" : "blocked";
+  return nodeRunVerdict(model, artifact, info, runtime, opts).state;
+}
+function nodeRunVerdict(model, artifact, info, runtime, opts) {
+  if (info.sealed) return { state: void 0 };
+  if (artifact.continuationPause?.decision === "pending") return { state: "pending" };
+  const continuationDenied = artifact.continuationPause?.decision === "denied";
   const id = artifact.id;
   const now = opts?.now ?? Date.now();
   const rt = runtime ?? {};
@@ -148090,51 +148293,57 @@ function nodeRunState(model, artifact, info, runtime, opts) {
   const blocked = opts?.blocked ?? blockedOf(model, id);
   const hasCause = (c) => diagnosis.causes.some((x2) => x2.category === c);
   const stallSaysHumanBall = stall?.kind === "waiting_human" && (stall.action === "discuss" || stall.action === "rework" || stall.action === "accept" || stall.action === "review");
-  if (stallSaysHumanBall) return "pending";
+  if (stallSaysHumanBall) return { state: "pending" };
+  if (continuationDenied && unresolvedEscalationsOf(model, id).length > 0) return { state: "pending" };
   const stallMasksHumanBall = stall === null || stall.kind === "running" || //                                   档 1
   stall.kind === "held" || //                                      档 4
   stall.kind === "failed" || //                                    档 5
   stall.kind === "waiting_agent" && stall.action === "rework" || // 档 2（owner=agent，P2 不适用）
   stall.kind === "waiting_human" && stall.action === "resolve_gap";
-  if (stallMasksHumanBall && humanBallPending(model, artifact)) return "pending";
-  if (hasCause("owner-pending") || hasCause("accept-barrier")) return "pending";
-  if (rt.status === "fused" || rt.fused || hasCause("runtime-fused")) return "pending";
+  if (stallMasksHumanBall && humanBallPending(model, artifact)) return { state: "pending" };
+  if (!artifact.owner.startsWith("actor:agent:") && openBackpressureOf(model, id).length > 0) return { state: "pending" };
+  if (hasCause("owner-pending") || hasCause("accept-barrier")) return { state: "pending" };
+  if (rt.status === "fused" || rt.fused || hasCause("runtime-fused")) return { state: "pending" };
   const heldEarlyReturn = hasCause("held");
-  if (heldEarlyReturn && (isPendingOwner(artifact.owner) || model.acceptBlockers.get(id))) return "pending";
-  if (heldEarlyReturn) return "held";
-  if (hasCause("graph-gap") || hasCause("graph-deadlock") || hasCause("residual")) return "blocked";
-  if (hasCause("runtime-backoff") || hasCause("runtime-silent")) return "blocked";
-  if (blocked.blocked && info.latestWorkState !== null) return "blocked";
-  if (stall?.kind === "failed" || rt.status === "failed") return "blocked";
-  if (hasCause("content-gate")) return "reviewing";
+  if (heldEarlyReturn && (isPendingOwner(artifact.owner) || model.acceptBlockers.get(id))) return { state: "pending" };
+  if (heldEarlyReturn && holdOf(model, id)?.source === "sla") return { state: "pending" };
+  if (model.reworkHalted?.has(id)) return { state: "pending" };
+  if (heldEarlyReturn || continuationDenied) return { state: "held" };
+  if (hasCause("graph-gap")) return { state: "blocked", blockedBy: "gap" };
+  if (hasCause("graph-deadlock")) return { state: "blocked", blockedBy: "deadlock" };
+  if (hasCause("residual")) return { state: "blocked", blockedBy: "residual" };
+  if (blocked.blocked && info.latestWorkState !== null) return { state: "blocked", blockedBy: "upstream" };
+  if (hasCause("content-gate")) return { state: "reviewing" };
   if (hasCause("resource-queued") || rt.queued) {
     const minDwell = opts?.queuedMinDwellMs ?? 2e3;
     const since = rt.queued?.since;
     if (since !== void 0) {
       const dwell = now - Date.parse(since);
-      if (dwell >= minDwell) return "queued";
+      if (dwell >= minDwell) return { state: "queued" };
     } else {
-      return "queued";
+      return { state: "queued" };
     }
   }
-  if (stall?.kind === "running") return "running";
-  if (rt.status === "running" || info.latestWorkState === "running") return "running";
-  if (stall?.kind === "waiting_agent") return "running";
-  if (info.latestWorkState === "success" && !info.latestAccepted) return "running";
-  if (info.latestWorkState === null) return "not_run";
-  if (info.latestAccepted) return "done";
-  return "not_run";
+  if (hasCause("runtime-backoff") || hasCause("runtime-silent")) return { state: "running" };
+  if (stall?.kind === "failed" || rt.status === "failed" || info.latestWorkState === "failed") return { state: "running" };
+  if (stall?.kind === "running") return { state: "running" };
+  if (rt.status === "running" || info.latestWorkState === "running") return { state: "running" };
+  if (stall?.kind === "waiting_agent") return { state: "running" };
+  if (info.latestWorkState === "success" && !info.latestAccepted) return { state: "running" };
+  if (info.latestWorkState === null) return { state: "not_run" };
+  if (info.latestAccepted) return { state: "done" };
+  return { state: "not_run" };
 }
 function evaluateNodeRunState(model, artifact, info, projection = {}, opts) {
   const stall = stallOf(model, artifact.id, projection.exposedRuntime, projection.signals);
-  const state = nodeRunState(
+  const verdict = nodeRunVerdict(
     model,
     artifact,
     info,
     { ...projection.signals ?? { hasInFlight: false }, status: projection.runtime?.status },
     { stall, blocked: blockedOf(model, artifact.id), ...opts ?? {} }
   );
-  return { state, stall };
+  return { ...verdict, stall };
 }
 function humanBallPending(model, artifact) {
   const id = artifact.id;
@@ -167513,6 +167722,18 @@ var init_assistants = __esm({
       setPlatformAdminChecker(fn) {
         this.opts.isPlatformAdmin = fn;
       }
+      /* ---------- 写侧同步边界（借给删 Agent 那道闸） ---------- */
+      /**
+       * 「给这个助理建 / 换绑定」与「删这个助理」的同步边界（🔴 2026-09-26 代码评审 R8 阻断项）。
+       *
+       * 本服务是绑定的唯一写入口，所以这把锁只能由它往外借：删 Agent 的那道闸
+       * （`governance/agent-manage-guard.ts` 的 `lockAgentBinding`）拿它把「重读绑定 → 判
+       * `ASSISTANT_BOUND` → 下发那笔停用」整段排进与换绑 / 认领 / 回归复用同一条队。
+       * 不把 `bindStore` 本身递出去：绑定的写面仍然只在这个类里。
+       */
+      withAgentBindingLock(agentId, fn) {
+        return this.opts.bindStore.withAgentLock(agentId, fn);
+      }
       /* ---------- 读 ---------- */
       getByHuman(humanId) {
         return this.opts.bindStore.getByHuman(humanId);
@@ -167535,19 +167756,23 @@ var init_assistants = __esm({
           const bond = await this.opts.bindStore.getByHuman(humanId);
           if (bond) return { agentId: bond.agentActorId, created: false, source: "existing" };
           const restored = await this.opts.bindStore.restoreArchivedBindingByHuman(humanId);
-          const restoredActor = restored ? await this.opts.registry.getActor(restored.agentActorId) : null;
-          if (restored && restoredActor?.status !== "active") {
-            await this.opts.bindStore.archiveBindingByHuman(humanId, "unbind");
-          } else if (restored) {
-            await this.audit({
-              kind: "assistant_bond",
-              humanId,
-              agentId: restored.agentActorId,
-              by,
-              at: this.now(),
-              detail: { origin: restored.origin, via: "rejoin-restore" }
+          if (restored) {
+            const alive2 = await this.opts.bindStore.withAgentLock(restored.agentActorId, async () => {
+              if ((await this.opts.registry.getActor(restored.agentActorId))?.status === "active") return true;
+              await this.opts.bindStore.archiveBindingByHuman(humanId, "unbind");
+              return false;
             });
-            return { agentId: restored.agentActorId, created: false, source: "existing" };
+            if (alive2) {
+              await this.audit({
+                kind: "assistant_bond",
+                humanId,
+                agentId: restored.agentActorId,
+                by,
+                at: this.now(),
+                detail: { origin: restored.origin, via: "rejoin-restore" }
+              });
+              return { agentId: restored.agentActorId, created: false, source: "existing" };
+            }
           }
           const agentId = await this._createLocked(humanId, by, "lazy-create");
           return { agentId, created: true, source: "lazy-created" };
@@ -167586,45 +167811,55 @@ var init_assistants = __esm({
         if (target.status !== "active") {
           throw Object.assign(new Error("\u76EE\u6807\u6570\u5B57\u5458\u5DE5\u672A\u5728\u5C97"), { code: "REBIND_AGENT_NOT_ELIGIBLE" });
         }
-        return this.opts.bindStore.withHumanLock(humanId, async () => {
-          if (await this.opts.bindStore.getByAgent(agentId)) {
-            throw Object.assign(new Error("\u8BE5\u6570\u5B57\u5458\u5DE5\u5DF2\u662F\u4ED6\u4EBA\u52A9\u7406"), { code: "REBIND_AGENT_NOT_ELIGIBLE" });
-          }
-          if (await this.opts.bindStore.getHistoryByAgent(agentId)) {
-            throw Object.assign(new Error("\u8BE5\u6570\u5B57\u5458\u5DE5\u66FE\u88AB\u8BA4\u9886\u8FC7\uFF0C\u4E0D\u53EF\u518D\u7ED1\u4E3A\u52A9\u7406"), { code: "REBIND_AGENT_NOT_ELIGIBLE" });
-          }
-          const archived = await this.opts.bindStore.archiveBindingByHuman(humanId, "unbind");
-          if (archived) {
-            if (archived.origin === "lazy-create") {
-              await this.opts.actors.disableActor(archived.agentActorId, by).catch(() => {
+        return this.opts.bindStore.withHumanLock(humanId, async () => (
+          /* 🔴 2026-09-26 代码评审 R8 阻断项：换绑与「删这个助理」必须在**同一把锁**里排队。
+             上面那次 `status !== "active"` 是锁外读的，而删除侧读绑定也在它自己的锁外——两边各自
+             看到「对方还没动」，结果就是绑定落在一个正被删掉的 agent 上：成员在组织内、助理没了
+             （组织页 PRD v1.6 禁的那个终态）。取锁顺序固定 human → agent，删除侧只取 agent 这一把，
+             所以不会成环。 */
+          this.opts.bindStore.withAgentLock(agentId, async () => {
+            if (await this.opts.bindStore.getByAgent(agentId)) {
+              throw Object.assign(new Error("\u8BE5\u6570\u5B57\u5458\u5DE5\u5DF2\u662F\u4ED6\u4EBA\u52A9\u7406"), { code: "REBIND_AGENT_NOT_ELIGIBLE" });
+            }
+            if (await this.opts.bindStore.getHistoryByAgent(agentId)) {
+              throw Object.assign(new Error("\u8BE5\u6570\u5B57\u5458\u5DE5\u66FE\u88AB\u8BA4\u9886\u8FC7\uFF0C\u4E0D\u53EF\u518D\u7ED1\u4E3A\u52A9\u7406"), { code: "REBIND_AGENT_NOT_ELIGIBLE" });
+            }
+            if ((await this.opts.registry.getActor(agentId))?.status !== "active") {
+              throw Object.assign(new Error("\u76EE\u6807\u6570\u5B57\u5458\u5DE5\u672A\u5728\u5C97"), { code: "REBIND_AGENT_NOT_ELIGIBLE" });
+            }
+            const archived = await this.opts.bindStore.archiveBindingByHuman(humanId, "unbind");
+            if (archived) {
+              if (archived.origin === "lazy-create") {
+                await this.opts.actors.disableActor(archived.agentActorId, by).catch(() => {
+                });
+              }
+              await this.audit({
+                kind: "assistant_bond_archived",
+                humanId,
+                agentId: archived.agentActorId,
+                by,
+                at: this.now(),
+                detail: { trigger: "rebind", nextAgentId: agentId, previousOrigin: archived.origin }
               });
             }
+            await this.opts.bindStore.insertBinding({
+              humanActorId: humanId,
+              agentActorId: agentId,
+              createdAt: this.now(),
+              createdBy: by,
+              origin: "claim"
+            });
             await this.audit({
-              kind: "assistant_bond_archived",
+              kind: "assistant_bond",
               humanId,
-              agentId: archived.agentActorId,
+              agentId,
               by,
               at: this.now(),
-              detail: { trigger: "rebind", nextAgentId: agentId, previousOrigin: archived.origin }
+              detail: { origin: "claim", via: "rebind", keepOriginalPosition: true }
             });
-          }
-          await this.opts.bindStore.insertBinding({
-            humanActorId: humanId,
-            agentActorId: agentId,
-            createdAt: this.now(),
-            createdBy: by,
-            origin: "claim"
-          });
-          await this.audit({
-            kind: "assistant_bond",
-            humanId,
-            agentId,
-            by,
-            at: this.now(),
-            detail: { origin: "claim", via: "rebind", keepOriginalPosition: true }
-          });
-          return { agentId, created: false, source: "existing" };
-        });
+            return { agentId, created: false, source: "existing" };
+          })
+        ));
       }
       /**
        * 主动解除绑定。懒创建助理同步停用；claim 来的数字员工只撤绑定、不停用 actor。
@@ -167713,20 +167948,21 @@ var init_assistants = __esm({
         await this.assertWritePermission(by, humanId);
         const agent = await this.opts.registry.getActor(agentId);
         if (!agent || agent.kind !== "agent") throw Object.assign(new Error("\u76EE\u6807\u4E0D\u662F agent \u5458\u5DE5"), { code: "LEGACY_AGENT_NOT_ELIGIBLE_FOR_REBIND" });
-        return this.opts.bindStore.withHumanLock(humanId, async () => {
+        return this.opts.bindStore.withHumanLock(humanId, async () => this.opts.bindStore.withAgentLock(agentId, async () => {
           if (await this.opts.bindStore.getByHuman(humanId)) throw Object.assign(new Error("\u8BE5\u771F\u4EBA\u5DF2\u6709\u7ED1\u5B9A\u52A9\u7406"), { code: "LEGACY_AGENT_NOT_ELIGIBLE_FOR_REBIND" });
           if (await this.opts.bindStore.getByAgent(agentId)) throw Object.assign(new Error("\u8BE5 agent \u5DF2\u88AB\u7ED1\u5B9A"), { code: "LEGACY_AGENT_NOT_ELIGIBLE_FOR_REBIND" });
           if (await this.opts.bindStore.getHistoryByAgent(agentId)) throw Object.assign(new Error("\u8BE5 agent \u5DF2\u88AB\u8BA4\u9886\u8FC7\uFF0C\u4E0D\u5165\u6362\u7ED1\u5019\u9009"), { code: "LEGACY_AGENT_NOT_ELIGIBLE_FOR_REBIND" });
           await this.opts.bindStore.insertBinding({ humanActorId: humanId, agentActorId: agentId, createdAt: this.now(), createdBy: by, origin: "claim" });
+          const current = await this.opts.registry.getActor(agentId) ?? agent;
           const keepPos = opts.keepOriginalPosition === true;
-          const nextRoles = keepPos ? agent.roles : ["assistant"];
-          const nextName = opts.newName && opts.newName !== agent.name ? opts.newName : agent.name;
-          if (JSON.stringify(nextRoles) !== JSON.stringify(agent.roles) || nextName !== agent.name || agent.status !== "active") {
+          const nextRoles = keepPos ? current.roles : ["assistant"];
+          const nextName = opts.newName && opts.newName !== current.name ? opts.newName : current.name;
+          if (JSON.stringify(nextRoles) !== JSON.stringify(current.roles) || nextName !== current.name || current.status !== "active") {
             await this.opts.actors.upsertActor({ id: agentId, kind: "agent", name: nextName, status: "active", roles: nextRoles }, by);
           }
-          await this.audit({ kind: "assistant_bond", humanId, agentId, by, at: this.now(), detail: { origin: "claim", previousRoles: agent.roles, keepOriginalPosition: keepPos } });
+          await this.audit({ kind: "assistant_bond", humanId, agentId, by, at: this.now(), detail: { origin: "claim", previousRoles: current.roles, keepOriginalPosition: keepPos } });
           return { agentId, humanId };
-        });
+        }));
       }
       /* ---------- opt-out 开关 ---------- */
       async setAutoAssign(humanId, on, by) {
@@ -168663,10 +168899,7 @@ function actorRefFallbackOf(id) {
   return avatar ? { avatar } : void 0;
 }
 function overviewRootIdOf(arts) {
-  const roots = arts.filter((a) => a.inputs.length === 0);
-  if (roots.length <= 1) return roots[0]?.id;
-  const consumed = new Set(arts.flatMap((a) => a.inputs.map((e) => e.to)));
-  return (roots.find((a) => !consumed.has(a.id)) ?? roots[0])?.id;
+  return headerRootIdOf(arts);
 }
 function buildWorkorderSummaries(model, resolveActor, resolveProject, dispatchPausedOf, projectionOf, viewer, resolveRoleExecutor) {
   const byWorkspace = /* @__PURE__ */ new Map();
@@ -168703,13 +168936,16 @@ function summaryOfWorkspace(model, workspace, arts, ref2, resolveProject, dispat
   const overviewRootId = overviewRootIdOf(arts);
   const stageMembers = arts.map((a, i) => {
     const info = members[i];
+    const verdict = nodeStateOf2 ? nodeStateOf2(a.id, info) : evaluateNodeRunState(model, a, info, projectionOf?.(a.id, info));
     return {
       info,
-      state: nodeStateOf2 ? nodeStateOf2(a.id, info) : evaluateNodeRunState(model, a, info, projectionOf?.(a.id, info)).state,
+      state: verdict.state,
+      ...verdict.blockedBy ? { blockedBy: verdict.blockedBy } : {},
       ...a.id === overviewRootId ? { overviewRoot: true } : {}
     };
   });
-  const stage = deriveStage(stageMembers, { dispatchPaused });
+  const awaitingDispatch = model.creationHeldWorkorders?.has(workspace) ?? false;
+  const stage = deriveStage(stageMembers, { dispatchPaused, awaitingDispatch });
   const requiresMeCount = viewer ? arts.reduce((n, a) => {
     if (a.id === overviewRootId) return n;
     if (lifecycleOf(model, a.id) !== "active") return n;
@@ -169057,7 +169293,7 @@ function buildWorkorderDetail(model, workspaceId, resolveActor, resolveProject,
       ...e.upstreamCancelled ? { upstreamCancelled: true } : {}
     })) : [];
     const pv = reviewerPreview?.(a.id);
-    const { state: runState, stall: stallRaw } = evaluateNodeRunState(model, a, info, { runtime, exposedRuntime, signals });
+    const { state: runState, blockedBy, stall: stallRaw } = evaluateNodeRunState(model, a, info, { runtime, exposedRuntime, signals });
     const stall = stallRaw ? (() => {
       const { actorId, blockers: rawBlockers, ...rest } = stallRaw;
       const blockers = rawBlockers?.map((bl) => ({
@@ -169077,7 +169313,7 @@ function buildWorkorderDetail(model, workspaceId, resolveActor, resolveProject,
     const mail = lifecycle === "active" ? openMailOf(model, a.id) : [];
     const requiresMeReason = lifecycle === "active" && a.id !== overviewRootId ? requiresMeReasonOf(model, a, viewer, requiresMeFacts) : null;
     const requiresMe = requiresMeReason !== null;
-    runStateById.set(a.id, runState);
+    runStateById.set(a.id, { state: runState, ...blockedBy ? { blockedBy } : {} });
     return {
       id: a.id,
       type: a.type,
@@ -169145,7 +169381,7 @@ function buildWorkorderDetail(model, workspaceId, resolveActor, resolveProject,
     void 0,
     void 0,
     resolveRoleExecutor,
-    (id) => runStateById.get(id)
+    (id) => runStateById.get(id) ?? { state: void 0 }
   );
   const edges = arts.flatMap(
     (a) => a.inputs.map((e) => ({ from: a.id, to: e.to, pinned: e.pinned, required: e.required }))
@@ -211687,6 +211923,7 @@ async function startOasisServer(opts) {
       void settleAuthorizationStatusLine(resume.origin, r, resume, draftId, needsAgentDelivery, storeFor, companyId);
     }
   };
+  opts.kernel.useContentStore?.(opts.blobs);
   const resolveEngine = opts.resolveEngine ?? (async () => ({ kernel: opts.kernel, oplog: opts.oplog, blobs: opts.blobs, ...opts.registry ? { registry: opts.registry } : {} }));
   const engineBus = opts.kernel.getBus?.();
   const engineEvents = opts.engineEvents ?? (engineBus ? (fn) => {
@@ -217543,6 +217780,13 @@ var init_memory_assistant_store = __esm({
       async withHumanLock(humanId, fn) {
         return this.mutex.run(humanId, fn);
       }
+      /**
+       * 按 agent 的那把（🔴 R8 阻断项，语义见 contract `AssistantBindStore.withAgentLock`）：
+       * 同一个 mutex map，键加 `agent\x1F` 前缀——与 Postgres 版同一套键形状，两边行为才对得上。
+       */
+      async withAgentLock(agentId, fn) {
+        return this.mutex.run(`agent${agentId}`, fn);
+      }
       async insertBinding(b2) {
         const hist = this.history.get(b2.agentActorId);
         if (hist && hist.firstBoundHuman !== b2.humanActorId) {
@@ -219108,6 +219352,7 @@ var memberKey, scopedKey, bridgeKey, migrationRow, MemoryControlPlaneStore;
 var init_memory_control_plane_store = __esm({
   "../testkit/src/memory-control-plane-store.ts"() {
     "use strict";
+    init_src();
     memberKey = (companyId, accountId) => `${companyId} ${accountId}`;
     scopedKey = (companyId, id) => `${companyId}\0${id}`;
     bridgeKey = (companyId, type, id) => `${companyId}\0${type}\0${id}`;
@@ -219148,6 +219393,19 @@ var init_memory_control_plane_store = __esm({
       // key = companyId\0operationId
       /** 存量身份映射审计（ADR D3.4）：**只追加**的一条数组，插入序即写入序。 */
       roleMigrations = [];
+      /**
+       * 成员行锁（模拟 PG 的 `SELECT … WHERE company_id FOR UPDATE`）：有人持有时为一个待决 Promise。
+       *
+       * 为什么内存版也需要它：本类的成员写方法**方法体里没有 await**，彼此天然原子；但
+       * `withCompanyMembersLocked` 的 `run` 是外部传进来的异步回调（员工页那笔 registry 写入），
+       * 它一 await 就给了其它请求穿插的机会——不拦的话内存版与 PG 版在**唯一一处会出事的地方**分叉。
+       * 所以每个成员写方法开头都排一次队（`while (this.membersLock) await this.membersLock`）：
+       * 方法体是同步的，队列排空那一刻进入就等价于「拿到锁」，中途不可能被穿插。
+       *
+       * 与 PG 的差别只有粒度：这里是**一把全局队列**（不按 companyId 分），内存 / 文件版量小，
+       * 跨公司多排一会儿无害；换来的是所有入口一行代码、不可能漏掉某个公司维度。
+       */
+      membersLock;
       // —— 公司 ——
       async createCompany(c) {
         if (this.companies.has(c.id)) throw new Error(`company already exists: ${c.id}`);
@@ -219226,6 +219484,7 @@ var init_memory_control_plane_store = __esm({
         this.members.delete(memberKey(companyId, accountId));
       }
       async removeMemberIfNotLastOwner(companyId, accountId) {
+        while (this.membersLock) await this.membersLock;
         const key2 = memberKey(companyId, accountId);
         const target = this.members.get(key2);
         if (!target) return { ok: false, reason: "not_found" };
@@ -219240,6 +219499,7 @@ var init_memory_control_plane_store = __esm({
         return { ok: true, member: { ...target } };
       }
       async removeMemberAndReleaseOwnedAgents(companyId, accountId, at2) {
+        while (this.membersLock) await this.membersLock;
         const target = this.members.get(memberKey(companyId, accountId));
         if (!target) return { ok: false, reason: "not_found" };
         if (target.role === "owner") return { ok: false, reason: "owner_protected" };
@@ -219255,6 +219515,7 @@ var init_memory_control_plane_store = __esm({
         return { ok: true, member: { ...target }, releasedAgents };
       }
       async updateMemberRoleIfNotLastOwner(companyId, accountId, role) {
+        while (this.membersLock) await this.membersLock;
         const key2 = memberKey(companyId, accountId);
         const target = this.members.get(key2);
         if (!target) return { ok: false, reason: "not_found" };
@@ -219269,7 +219530,18 @@ var init_memory_control_plane_store = __esm({
         this.members.set(key2, updated);
         return { ok: true, member: { ...updated } };
       }
+      async updateMemberDisplayName(companyId, accountId, displayName3, opts) {
+        while (this.membersLock) await this.membersLock;
+        const key2 = memberKey(companyId, accountId);
+        const target = this.members.get(key2);
+        if (!target) return { ok: false, reason: "not_found" };
+        if (opts?.requireNotOwner && target.role === "owner") return { ok: false, reason: "owner_protected" };
+        const updated = { ...target, displayName: displayName3 };
+        this.members.set(key2, updated);
+        return { ok: true, member: { ...updated } };
+      }
       async setSoleCompanyOwner(companyId, toAccountId, opts) {
+        while (this.membersLock) await this.membersLock;
         const target = this.members.get(memberKey(companyId, toAccountId));
         if (!target) return { ok: false, reason: "not_found" };
         if (opts?.requireCurrentOwner !== void 0) {
@@ -219297,8 +219569,31 @@ var init_memory_control_plane_store = __esm({
         this.members.set(memberKey(companyId, toAccountId), owner);
         return { ok: true, owner: { ...owner }, demoted };
       }
+      async withCompanyMembersLocked(companyId, run) {
+        while (this.membersLock) await this.membersLock;
+        let release;
+        this.membersLock = new Promise((resolve12) => {
+          release = resolve12;
+        });
+        let ended = false;
+        const readLocked = () => [...this.members.values()].filter((m2) => m2.companyId === companyId).map((m2) => ({ ...m2 }));
+        const lease = {
+          beginExternalWrite: async () => {
+            if (ended) throw new CompanyMembersLockLostError(companyId, "section_ended", false);
+            return readLocked();
+          }
+        };
+        try {
+          return await run(readLocked(), lease);
+        } finally {
+          ended = true;
+          this.membersLock = void 0;
+          release();
+        }
+      }
       // —— 存量身份映射（ADR D3）——
       async migrateSoleCompanyOwner(companyId, toAccountId, audit2) {
+        while (this.membersLock) await this.membersLock;
         const target = this.members.get(memberKey(companyId, toAccountId));
         if (!target) return { ok: false, reason: "not_found" };
         const others = [];
@@ -219362,6 +219657,7 @@ var init_memory_control_plane_store = __esm({
         return true;
       }
       async commitAcceptedInvitation(invitationId, now, member) {
+        while (this.membersLock) await this.membersLock;
         const inv = this.invitations.get(invitationId);
         if (!inv) return { ok: false, reason: "not_found" };
         if (inv.status !== "pending") return { ok: false, reason: "not_pending", current: { ...inv } };
@@ -219370,18 +219666,13 @@ var init_memory_control_plane_store = __esm({
           this.invitations.set(invitationId, inv);
           return { ok: false, reason: "expired", current: { ...inv } };
         }
+        const key2 = memberKey(member.companyId, member.accountId);
+        const seated = this.members.get(key2);
+        if (seated) return { ok: false, reason: "already_member", member: { ...seated } };
         inv.status = "accepted";
         this.invitations.set(invitationId, inv);
-        const key2 = memberKey(member.companyId, member.accountId);
-        const prev = this.members.get(key2);
-        const stored = {
-          ...member,
-          ...prev?.displayName !== void 0 ? { displayName: prev.displayName } : {},
-          ...prev?.onboardingCompletedAt !== void 0 ? { onboardingCompletedAt: prev.onboardingCompletedAt } : {},
-          ...prev?.onboardingStep !== void 0 ? { onboardingStep: prev.onboardingStep } : {}
-        };
-        this.members.set(key2, stored);
-        return { ok: true, invitation: { ...inv }, member: { ...stored } };
+        this.members.set(key2, { ...member });
+        return { ok: true, invitation: { ...inv }, member: { ...member } };
       }
       // —— 共享邀请链接 ——
       async createInviteLink(link) {
@@ -224617,6 +224908,7 @@ var init_control_plane_file_store = __esm({
       "removeMember",
       "removeMemberIfNotLastOwner",
       "updateMemberRoleIfNotLastOwner",
+      "updateMemberDisplayName",
       "setSoleCompanyOwner",
       "removeMemberAndReleaseOwnedAgents",
       "migrateSoleCompanyOwner",
@@ -224721,6 +225013,10 @@ var init_control_plane_file_store = __esm({
 });
 
 // ../server/src/company-engine-router.ts
+function withContentStore(engine) {
+  engine.kernel.useContentStore?.(engine.blobs);
+  return engine;
+}
 var CompanyEngineRouter;
 var init_company_engine_router = __esm({
   "../server/src/company-engine-router.ts"() {
@@ -224728,7 +225024,7 @@ var init_company_engine_router = __esm({
     CompanyEngineRouter = class {
       constructor(opts) {
         this.opts = opts;
-        this.cache.set(opts.defaultCompanyId, opts.defaultEngine);
+        this.cache.set(opts.defaultCompanyId, withContentStore(opts.defaultEngine));
       }
       cache = /* @__PURE__ */ new Map();
       /**
@@ -224760,6 +225056,7 @@ var init_company_engine_router = __esm({
         if (pending) return pending;
         const building = buildEngine(companyId).then(
           (engine) => {
+            withContentStore(engine);
             this.cache.set(companyId, engine);
             this.inflight.delete(companyId);
             return engine;
@@ -233446,7 +233743,13 @@ function mayManageAgent(caller, subject) {
 }
 async function assertMayManageAgent(guard, ctx, agent) {
   if (!guard) return;
-  const role = await guard.callerRole(ctx.companyId, ctx.callerActorId);
+  const [role, subject] = await Promise.all([
+    guard.memberRole(ctx.companyId, ctx.callerActorId),
+    resolveAgentSubject(guard, ctx, agent)
+  ]);
+  assertManageAgentWithRole(ctx.callerActorId, role, subject);
+}
+async function resolveAgentSubject(guard, ctx, agent) {
   const subject = { positions: agent.positions };
   if (isAssistantAgent(subject)) {
     const human = await guard.boundHuman(ctx.companyId, agent.id);
@@ -233455,14 +233758,27 @@ async function assertMayManageAgent(guard, ctx, agent) {
       subject.boundHumanReportsTo = await guard.reportsTo(ctx.companyId, human) ?? void 0;
     }
   }
-  if (mayManageAgent({ role, actorId: ctx.callerActorId }, subject)) return;
+  return subject;
+}
+function assertManageAgentWithRole(callerActorId, callerRole, subject) {
+  if (mayManageAgent({ role: callerRole, actorId: callerActorId }, subject)) return;
   throw new AgentManageForbiddenError(
     isAssistantAgent(subject) ? "\u53EA\u6709\u672C\u4EBA\u3001\u5176\u76F4\u63A5\u4E0A\u7EA7\u6216\u7EC4\u7EC7\u7BA1\u7406\u5458 / \u7BA1\u7406\u5458\u53EF\u4EE5\u7BA1\u7406\u8FD9\u4E2A\u52A9\u7406" : "\u53EA\u6709\u7EC4\u7EC7\u7BA1\u7406\u5458 / \u7BA1\u7406\u5458\u53EF\u4EE5\u7BA1\u7406\u4E13\u5BB6 Agent"
   );
 }
+function assistantBoundToMember(subject, roleOf) {
+  if (!isAssistantAgent(subject)) return false;
+  const human = subject.boundHumanActorId;
+  if (human === void 0) return false;
+  return roleOf(human) !== void 0;
+}
+function assertAgentDeletable(subject, roleOf) {
+  if (!assistantBoundToMember(subject, roleOf)) return;
+  throw new AgentManageForbiddenError(ASSISTANT_BOUND_MESSAGE, "ASSISTANT_BOUND");
+}
 async function assertCompanyManager(guard, ctx, what) {
   if (!guard) return;
-  const role = await guard.callerRole(ctx.companyId, ctx.callerActorId);
+  const role = await guard.memberRole(ctx.companyId, ctx.callerActorId);
   if (isCompanyManager(role)) return;
   throw new AgentManageForbiddenError(`\u53EA\u6709\u7EC4\u7EC7\u7BA1\u7406\u5458 / \u7BA1\u7406\u5458\u53EF\u4EE5${what}`);
 }
@@ -233472,23 +233788,79 @@ async function assertMayCreateAgent(guard, ctx) {
 async function assertMaySelfOrManage(guard, ctx, targetActorId) {
   if (!guard) return;
   if (ctx.callerActorId === targetActorId) return;
-  const role = await guard.callerRole(ctx.companyId, ctx.callerActorId);
-  if (isCompanyManager(role)) return;
+  const [role, targetRole] = await Promise.all([
+    guard.memberRole(ctx.companyId, ctx.callerActorId),
+    guard.memberRole(ctx.companyId, targetActorId)
+  ]);
+  assertSelfOrManageWithRoles(ctx.callerActorId, targetActorId, role, targetRole);
+}
+function assertSelfOrManageWithRoles(callerActorId, targetActorId, callerRole, targetRole) {
+  if (callerActorId === targetActorId) return;
+  if (targetRole === "owner") {
+    throw new AgentManageForbiddenError(OWNER_PROTECTED_PROFILE_MESSAGE, "OWNER_PROTECTED");
+  }
+  if (isCompanyManager(callerRole)) return;
   throw new AgentManageForbiddenError("\u53EA\u80FD\u4FEE\u6539\u81EA\u5DF1\u7684\u6863\u6848\uFF1B\u6539\u4ED6\u4EBA\u7684\u9700\u8981\u7EC4\u7EC7\u7BA1\u7406\u5458 / \u7BA1\u7406\u5458\u6743\u9650");
 }
-var ASSISTANT_POSITION, AgentManageForbiddenError;
+async function runGuardedActorWrite(guard, ctx, target, write) {
+  if (!guard) return write();
+  if (target.kind !== "agent" && ctx.callerActorId === target.id) return write();
+  const subject = target.kind === "agent" ? await resolveAgentSubject(guard, ctx, { id: target.id, positions: target.positions }) : void 0;
+  const nextSubject = subject !== void 0 && target.nextPositions !== void 0 && isAssistantAgent(subject) !== isAssistantAgent({ positions: target.nextPositions }) ? await resolveAgentSubject(guard, ctx, { id: target.id, positions: target.nextPositions }) : void 0;
+  const check2 = (roleOf, latest = subject) => {
+    if (latest === void 0) {
+      assertSelfOrManageWithRoles(ctx.callerActorId, target.id, roleOf(ctx.callerActorId), roleOf(target.id));
+      return;
+    }
+    const callerRole = roleOf(ctx.callerActorId);
+    assertManageAgentWithRole(ctx.callerActorId, callerRole, latest);
+    if (nextSubject) assertManageAgentWithRole(ctx.callerActorId, callerRole, nextSubject);
+    if (target.intent === "delete") assertAgentDeletable(latest, roleOf);
+  };
+  const deletingAssistant = subject !== void 0 && target.intent === "delete" && isAssistantAgent(subject);
+  const withBindingPinned = async (run) => {
+    if (!deletingAssistant) return run(subject);
+    const pinned = async () => run(await resolveAgentSubject(guard, ctx, { id: target.id, positions: target.positions }));
+    return guard.lockAgentBinding ? guard.lockAgentBinding(ctx.companyId, target.id, pinned) : pinned();
+  };
+  if (!guard.lockMembers) {
+    return withBindingPinned(async (latest) => {
+      const boundHuman = target.intent === "delete" && latest?.boundHumanActorId !== ctx.callerActorId ? latest?.boundHumanActorId : void 0;
+      const [callerRole, targetRole, boundHumanRole] = await Promise.all([
+        guard.memberRole(ctx.companyId, ctx.callerActorId),
+        // agent 目标不看「目标的成员角色」（agent 不是成员，D8.5），少发一次点查。
+        latest === void 0 ? guard.memberRole(ctx.companyId, target.id) : Promise.resolve(void 0),
+        boundHuman !== void 0 ? guard.memberRole(ctx.companyId, boundHuman) : Promise.resolve(void 0)
+      ]);
+      check2((actorId) => actorId === ctx.callerActorId ? callerRole : actorId === target.id ? targetRole : actorId === boundHuman ? boundHumanRole : void 0, latest);
+      return write();
+    });
+  }
+  return guard.lockMembers(ctx.companyId, async (roleOf, lease) => {
+    check2(roleOf);
+    return withBindingPinned(async (latest) => {
+      const fresh = await lease.beginExternalWrite();
+      check2(fresh, latest);
+      return write();
+    });
+  });
+}
+var ASSISTANT_POSITION, AgentManageForbiddenError, OWNER_PROTECTED_PROFILE_MESSAGE, ASSISTANT_BOUND_MESSAGE;
 var init_agent_manage_guard = __esm({
   "../server/src/governance/agent-manage-guard.ts"() {
     "use strict";
     ASSISTANT_POSITION = "assistant";
     AgentManageForbiddenError = class extends Error {
       status = 403;
-      code = "FORBIDDEN";
-      constructor(message) {
+      code;
+      constructor(message, code2 = "FORBIDDEN") {
         super(message);
         this.name = "AgentManageForbiddenError";
+        this.code = code2;
       }
     };
+    OWNER_PROTECTED_PROFILE_MESSAGE = "\u7EC4\u7EC7\u7BA1\u7406\u5458\u4E0D\u53EF\u88AB\u7F16\u8F91\u3001\u964D\u7EA7\u6216\u79FB\u9664\uFF0C\u53EA\u80FD\u7531\u672C\u4EBA\u8F6C\u4EA4\u6216\u89E3\u6563\u7EC4\u7EC7";
+    ASSISTANT_BOUND_MESSAGE = "\u8BE5\u52A9\u7406\u4ECD\u7ED1\u5B9A\u7740\u7EC4\u7EC7\u5185\u7684\u6210\u5458\uFF0C\u4E0D\u80FD\u5220\u9664\uFF1B\u8981\u5148\u89E3\u7ED1\uFF08\u6216\u7B49\u8BE5\u6210\u5458\u79BB\u5F00\u7EC4\u7EC7\uFF09";
   }
 });
 
@@ -233596,16 +233968,32 @@ function actorsDomain(opts) {
     }
     await asForbidden(() => assertMayManageAgent(opts.agentManageGuard, ctx, { id: actor.id, positions: actor.roles }));
   };
-  const guardPositionsChange = async (req, existing, nextPositions) => {
-    if (existing.kind !== "agent" || nextPositions === void 0) return;
-    if (isAssistantAgent({ positions: existing.roles }) === isAssistantAgent({ positions: nextPositions })) return;
-    const ctx = { companyId: req.auth.companyId, callerActorId: req.auth.actor };
-    await asForbidden(() => assertMayManageAgent(opts.agentManageGuard, ctx, { id: existing.id, positions: nextPositions }));
-  };
-  const guardExistingActorWrite = async (req, service, actorId) => {
+  const requireActor = async (service, actorId) => {
     const existing = await service.getActor(actorId);
     if (!existing) throw new ApiError(404, "NOT_FOUND", `\u6CA1\u6709\u8FD9\u4E2A\u5458\u5DE5\uFF1A${actorId}`);
+    return existing;
+  };
+  const guardExistingActorWrite = async (req, service, actorId) => {
+    const existing = await requireActor(service, actorId);
     await guardAgentWrite(req, existing);
+    return existing;
+  };
+  const guardedActorWrite = async (req, existing, nextPositions, write, intent = "update") => {
+    try {
+      return await runGuardedActorWrite(
+        opts.agentManageGuard,
+        { companyId: req.auth.companyId, callerActorId: req.auth.actor },
+        { id: existing.id, kind: existing.kind, positions: existing.roles, nextPositions, intent },
+        write
+      );
+    } catch (e) {
+      if (e instanceof AgentManageForbiddenError) throw new ApiError(e.status, e.code, e.message);
+      if (isCompanyMembersLockLost(e)) {
+        const undetermined = e.writeIssued === true;
+        throw new ApiError(503, "MEMBERS_LOCK_UNAVAILABLE", undetermined ? "\u7EC4\u7EC7\u6210\u5458\u6B63\u5728\u53D8\u66F4\u4E2D\uFF0C\u8FD9\u6B21\u4FEE\u6539\u662F\u5426\u751F\u6548\u672A\u80FD\u786E\u8BA4\uFF0C\u8BF7\u5237\u65B0\u540E\u67E5\u770B" : "\u7EC4\u7EC7\u6210\u5458\u6B63\u5728\u53D8\u66F4\u4E2D\uFF0C\u8FD9\u6B21\u4FEE\u6539\u6CA1\u6709\u751F\u6548\uFF0C\u8BF7\u91CD\u8BD5");
+      }
+      throw e;
+    }
   };
   const revealLimits = opts.credentialRevealLimits ?? { perSession: 200, perSessionPerKey: 20 };
   const revealLimiter = new RevealRateLimiter(revealLimits.perSession, revealLimits.perSessionPerKey);
@@ -233663,11 +234051,12 @@ function actorsDomain(opts) {
         companyId: req.auth.companyId,
         callerActorId: req.auth.actor
       }));
+      const existing = await service.getActor(b2.id);
       const { id, kind, name } = b2;
       const positions = positionsFromPayload(b2);
       const avatar = avatarRefFromPayload(b2);
       const tags = tagsFromPayload(b2);
-      const actor = await asApiError(() => service.upsertActor(
+      const write = () => asApiError(() => service.upsertActor(
         {
           id,
           kind,
@@ -233683,18 +234072,16 @@ function actorsDomain(opts) {
         },
         req.auth.actor
       ));
+      const actor = existing ? await guardedActorWrite(req, existing, positions, write) : await write();
       return { status: 201, body: actorApiRecord(actor) };
     });
     router.patch("/api/actors/:id", async (req) => {
       const { service } = await resolveCtx(req.auth.companyId);
-      const existing = await service.getActor(req.params.id);
-      if (!existing) throw new ApiError(404, "NOT_FOUND", `\u6CA1\u6709\u8FD9\u4E2A\u5458\u5DE5\uFF1A${req.params.id}`);
-      await guardAgentWrite(req, existing);
+      const existing = await requireActor(service, req.params.id);
       const b2 = req.body ?? {};
       const positions = positionsFromPayload(b2);
       const avatar = avatarRefFromPayload(b2);
       const tags = tagsFromPayload(b2);
-      await guardPositionsChange(req, existing, positions);
       const {
         positions: _positions,
         id: _id,
@@ -233706,7 +234093,8 @@ function actorsDomain(opts) {
         tags: _tags,
         ...patch
       } = b2;
-      const actor = await asApiError(() => service.upsertActor({
+      const intent = b2.status === "disabled" ? "delete" : "update";
+      const actor = await guardedActorWrite(req, existing, positions, () => asApiError(() => service.upsertActor({
         ...existing,
         ...patch,
         // 档案展示字段：显式给（含清空）——空串/null 归一为 undefined（写库落 NULL）；未传则保留原值
@@ -233720,27 +234108,33 @@ function actorsDomain(opts) {
         ...positions !== void 0 ? { roles: positions } : {},
         id: existing.id,
         kind: existing.kind
-      }, req.auth.actor));
+      }, req.auth.actor)), intent);
       return { status: 200, body: actorApiRecord(actor) };
     });
     router.delete("/api/actors/:id", async (req) => {
       const { service } = await resolveCtx(req.auth.companyId);
-      await guardExistingActorWrite(req, service, req.params.id);
-      await service.disableActor(req.params.id, req.auth.actor);
+      const existing = await requireActor(service, req.params.id);
+      await guardedActorWrite(
+        req,
+        existing,
+        void 0,
+        () => service.disableActor(req.params.id, req.auth.actor),
+        "delete"
+      );
       return { status: 200, body: { ok: true } };
     });
     router.post("/api/actors/:id/avatar", async (req) => {
       const { service, blobs } = await resolveCtx(req.auth.companyId);
       if (!blobs) throw new ApiError(501, "NOT_IMPLEMENTED", "blob \u5B58\u50A8\u672A\u63A5\u5165");
-      await guardExistingActorWrite(req, service, req.params.id);
+      const existing = await guardExistingActorWrite(req, service, req.params.id);
       const ref2 = await storeImageBlob(blobs, req.body?.data);
-      const actor = await service.setActorAvatar(req.params.id, ref2, req.auth.actor);
+      const actor = await guardedActorWrite(req, existing, void 0, () => service.setActorAvatar(req.params.id, ref2, req.auth.actor));
       return { status: 201, body: { avatar: actor.avatar } };
     });
     router.delete("/api/actors/:id/avatar", async (req) => {
       const { service } = await resolveCtx(req.auth.companyId);
-      await guardExistingActorWrite(req, service, req.params.id);
-      await service.setActorAvatar(req.params.id, null, req.auth.actor);
+      const existing = await requireActor(service, req.params.id);
+      await guardedActorWrite(req, existing, void 0, () => service.setActorAvatar(req.params.id, null, req.auth.actor));
       return { status: 200, body: { ok: true } };
     });
     router.post("/api/teams/:id/icon", async (req) => {
@@ -242544,15 +242938,9 @@ function collabDomain(opts) {
         if (snap?.workorder.dispatchPaused && !isHumanActor(req.auth.actor)) {
           return { status: 403, body: { error: { code: "forbidden", message: "\u6682\u505C\u671F\u95F4\u5F55\u5165\u5DE5\u5355\u6B63\u6587\u4EC5\u9650\u4EBA\u7C7B\u64CD\u4F5C" } } };
         }
-        const contentRef = await blobs.put(new TextEncoder().encode(text7));
-        if (snap?.workorder.dispatchPaused) {
-          await kernel.recordPausedRevision({ artifactId: rootId, actor: req.auth.actor, contentRef, note: "\u7F16\u8F91\u5DE5\u5355\u9875\u5934\u6B63\u6587" });
-          return { status: 200, body: { overview: text7, concluded: false } };
-        }
-        await kernel.proposeRevision({ artifactId: rootId, actor: req.auth.actor, contentRef, reason: "\u7F16\u8F91\u5DE5\u5355\u9875\u5934\u6B63\u6587" });
-        await kernel.advanceQueue(rootId, req.auth.actor);
-        const result = await kernel.conclude({ artifactId: rootId, actor: req.auth.actor, note: "\u7F16\u8F91\u5DE5\u5355\u9875\u5934\u6B63\u6587" });
-        return { status: 200, body: { overview: text7, concluded: result.kind !== "gate-pending" } };
+        kernel.useContentStore(blobs);
+        const result = await kernel.publishSeedContent({ artifactId: rootId, actor: req.auth.actor, text: text7, note: "\u7F16\u8F91\u5DE5\u5355\u9875\u5934\u6B63\u6587" });
+        return { status: 200, body: { overview: text7, concluded: result.concluded } };
       } catch (err) {
         if (err instanceof KernelError) {
           return {
@@ -243198,16 +243586,34 @@ var init_service6 = __esm({
        * 改成员在本公司的昵称（组织模型 ADR §4.1 `company_member.display_name`）。
        * 每公司独立：**不回写 `account.name`**——同一个人在 A 公司叫「小爱」、在 B 公司叫「Alice L.」是常态。
        * trim 后不得为空（空昵称等于没有昵称，那应该用「不传」表达，而不是存一个空串进去）。
+       *
+       * 🔴 2026-09-24 QA 第 3 轮回压的 P0 越权（ADR D5.1 / 验收标准第 3 条）：这条路径此前
+       * **既不问调用者是谁、也不问目标是谁**，只 `getMember` 读一行再 `upsertMember` 写回去。
+       * 于是管理员 A1 用自己的登录会话直接 `PATCH …/members/<唯一组织管理员>` 带 `displayName`
+       * 就能改掉组织管理员的资料（HTTP 200，刷新后生效）——前端把编辑入口藏了，服务端没有闸。
+       *
+       * 修法与 `changeMemberRole` / `removeMember` 同一套，不另造判据：
+       *  - `callerAccountId !== accountId`（**改别人的**）→ 走原子原语并要求「目标不是 owner」，
+       *    复核在**锁内**、读的是目标的最新身份（并发转交刚把目标升成组织管理员也拦得住），
+       *    被拒时报与另外两条同一个 `403 OWNER_PROTECTED`；
+       *  - `callerAccountId === accountId`（**改自己的**）→ 不复核身份。自己永远能改自己的名字，
+       *    组织管理员本人也在入职向导第 1 步走这条路（`useSetMemberDisplayName`），收紧会把他卡死。
+       *
+       * 两支都走 `updateMemberDisplayName`——它**只写 display_name 一列**。旧的整行 `upsertMember`
+       * 还有第二个坑：`SET role = $4` 无条件回写，读到写之间若有一次转交落地，这一笔昵称会把
+       * 新 owner 的 role 写回旧值，组织当场 0 位 owner（QA R7 / R12 同形状的竞态，换了个入口）。
        */
-      async setMemberDisplayName(companyId, accountId, displayName3) {
+      async setMemberDisplayName(companyId, accountId, displayName3, callerAccountId) {
         const trimmed = displayName3.trim();
         if (!trimmed) throw new CompanyError(400, "BAD_REQUEST", "displayName \u4E0D\u80FD\u4E3A\u7A7A");
         await this.requireCompany(companyId);
-        const member = await this.store.getMember(companyId, accountId);
-        if (!member) throw new CompanyError(404, "NOT_FOUND", `\u4E0D\u662F\u8BE5\u516C\u53F8\u6210\u5458\uFF1A${accountId}`);
-        const next = { ...member, displayName: trimmed };
-        await this.store.upsertMember(next);
-        return next;
+        const editingSomeoneElse = callerAccountId !== accountId;
+        const res = await this.store.updateMemberDisplayName(companyId, accountId, trimmed, {
+          requireNotOwner: editingSomeoneElse
+        });
+        if (res.ok) return res.member;
+        if (res.reason === "not_found") throw new CompanyError(404, "NOT_FOUND", `\u4E0D\u662F\u8BE5\u516C\u53F8\u6210\u5458\uFF1A${accountId}`);
+        throw this.ownerProtected();
       }
       /**
        * 「移除前预检」：确认成员可被移除，返回其 Membership（含 actorId）——**不删**。
@@ -243664,6 +244070,8 @@ var init_service6 = __esm({
         if (mine !== void 0 && mine !== normalizeEmail(inv.email)) {
           throw new CompanyError(403, "EMAIL_MISMATCH", "\u767B\u5F55\u8EAB\u4EFD\u4E0E\u88AB\u9080\u8BF7\u90AE\u7BB1\u4E0D\u7B26");
         }
+        const member = await this.store.getMember(inv.companyId, accepter.accountId);
+        if (member) throw new CompanyError(409, "ALREADY_MEMBER", "\u4F60\u5DF2\u7ECF\u662F\u8FD9\u4E2A\u56E2\u961F\u7684\u6210\u5458");
         return inv;
       }
       /**
@@ -243697,6 +244105,7 @@ var init_service6 = __esm({
         if (res.ok) return res.member;
         if (res.reason === "not_found") throw new CompanyError(404, "NOT_FOUND", `\u6CA1\u6709\u8FD9\u4E2A\u9080\u8BF7\uFF1A${inv.id}`);
         if (res.reason === "expired") throw new CompanyError(410, "EXPIRED", "\u9080\u8BF7\u5DF2\u8FC7\u671F");
+        if (res.reason === "already_member") throw new CompanyError(409, "ALREADY_MEMBER", "\u4F60\u5DF2\u7ECF\u662F\u8FD9\u4E2A\u56E2\u961F\u7684\u6210\u5458");
         throw new CompanyError(409, "NOT_PENDING", `\u9080\u8BF7\u5DF2\u5904\u7406\uFF08${res.current.status}\uFF09`);
       }
       /**
@@ -244179,7 +244588,7 @@ function companiesDomain(opts) {
         if (typeof b2.displayName !== "string" || !b2.displayName.trim()) {
           throw new ApiError(400, "BAD_REQUEST", "displayName \u987B\u4E3A\u975E\u7A7A\u5B57\u7B26\u4E32");
         }
-        member = await service.setMemberDisplayName(cid, aid, b2.displayName).catch(mapErr);
+        member = await service.setMemberDisplayName(cid, aid, b2.displayName, me.accountId).catch(mapErr);
         await syncActorNameToDisplayName(member, req.auth.actor);
       }
       return { status: 200, body: member };
@@ -260271,10 +260680,24 @@ var init_postgres_assistant_store = __esm({
         return new _PostgresAssistantBindStore(pool, schema, opts?.companyId);
       }
       async withHumanLock(humanId, fn) {
+        return this.withKeyLock(this.lockSubject ? `${this.lockSubject}${humanId}` : humanId, fn);
+      }
+      /**
+       * 按 agent 的那把（🔴 R8 阻断项，语义见 contract `AssistantBindStore.withAgentLock`）。
+       *
+       * 键多带一段 `agent` 前缀：human 键的形状（`<company>\x1F<id>`）一个字节不动——那一段
+       * 有真 PG 回归盯着（`postgres-assistant-store-lockkey.postgres.test.ts`）。ActorId 本来就分
+       * `actor:human:` / `actor:agent:` 两个命名空间、撞不上，前缀是为了让锁键读起来就知道锁的是谁。
+       */
+      async withAgentLock(agentId, fn) {
+        const key2 = `agent${agentId}`;
+        return this.withKeyLock(this.lockSubject ? `${this.lockSubject}${key2}` : key2, fn);
+      }
+      /** 两把锁共用的临界区：一条独占连接上开事务、取 xact advisory lock、跑完即提交（锁随事务放）。 */
+      async withKeyLock(lockKey, fn) {
         const client = await this.pool.connect();
         try {
           await client.query("BEGIN");
-          const lockKey = this.lockSubject ? `${this.lockSubject}${humanId}` : humanId;
           await client.query("SELECT pg_advisory_xact_lock($1::int4, hashtext($2)::int4)", [ASSISTANT_LOCK_NAMESPACE, lockKey]);
           const out = await fn();
           await client.query("COMMIT");
@@ -261648,17 +262071,22 @@ var init_postgres_control_plane = __esm({
     "use strict";
     init_esm();
     init_pg_ident();
+    init_src();
     ident8 = (s2) => {
       quoteIdent2(s2);
       return s2;
     };
     PostgresControlPlaneStore = class _PostgresControlPlaneStore {
-      constructor(pool, schema) {
+      constructor(pool, schema, opts = {}) {
         this.pool = pool;
         this.s = `"${ident8(schema)}"`;
+        this.membersLockWriteBudgetMs = opts.membersLockWriteBudgetMs ?? 3e4;
+        this.membersLockHeartbeatMs = opts.membersLockHeartbeatMs ?? 5e3;
       }
       s;
-      static async open(pool, schema = "public") {
+      membersLockWriteBudgetMs;
+      membersLockHeartbeatMs;
+      static async open(pool, schema = "public", opts = {}) {
         const s2 = ident8(schema);
         await pool.query(`CREATE SCHEMA IF NOT EXISTS "${s2}"`);
         await pool.query(`
@@ -261875,7 +262303,7 @@ var init_postgres_control_plane = __esm({
       )`);
         await pool.query(`CREATE INDEX IF NOT EXISTS company_member_role_migrations_company_idx ON "${s2}".company_member_role_migrations (company_id, applied_at DESC)`);
         await ensureOneOwnerInvariant(pool, s2);
-        return new _PostgresControlPlaneStore(pool, schema);
+        return new _PostgresControlPlaneStore(pool, schema, opts);
       }
       // —— 公司 ——
       async createCompany(c) {
@@ -262113,6 +262541,40 @@ var init_postgres_control_plane = __esm({
           client.release();
         }
       }
+      async updateMemberDisplayName(companyId, accountId, displayName3, opts) {
+        const client = await this.pool.connect();
+        try {
+          await client.query("BEGIN");
+          const all2 = await client.query(
+            `SELECT company_id, account_id, actor_id, role, display_name, onboarding_completed_at, onboarding_step
+           FROM ${this.s}.company_members WHERE company_id = $1 FOR UPDATE`,
+            [companyId]
+          );
+          const rows = all2.rows.map(rowToMember);
+          const target = rows.find((m2) => m2.accountId === accountId);
+          if (!target) {
+            await client.query("ROLLBACK");
+            return { ok: false, reason: "not_found" };
+          }
+          if (opts?.requireNotOwner && target.role === "owner") {
+            await client.query("ROLLBACK");
+            return { ok: false, reason: "owner_protected" };
+          }
+          await client.query(
+            `UPDATE ${this.s}.company_members SET display_name = $3, updated_at = now()
+           WHERE company_id = $1 AND account_id = $2`,
+            [companyId, accountId, displayName3]
+          );
+          await client.query("COMMIT");
+          return { ok: true, member: { ...target, displayName: displayName3 } };
+        } catch (e) {
+          await client.query("ROLLBACK").catch(() => {
+          });
+          throw e;
+        } finally {
+          client.release();
+        }
+      }
       async setSoleCompanyOwner(companyId, toAccountId, opts) {
         const client = await this.pool.connect();
         try {
@@ -262180,6 +262642,83 @@ var init_postgres_control_plane = __esm({
           client.release();
         }
       }
+      async withCompanyMembersLocked(companyId, run) {
+        const client = await this.pool.connect();
+        let writeIssued = false;
+        let sectionEnded = false;
+        let lost;
+        let broken;
+        let abandon;
+        const lose = (reason, err) => {
+          if (reason === "budget_exceeded" && writeIssued) return;
+          lost ??= { reason, ...err ? { err } : {} };
+          if (err) broken ??= err;
+          if (!writeIssued) abandon?.(new CompanyMembersLockLostError(companyId, reason, false));
+        };
+        const onClientError = (err) => lose("connection_lost", err);
+        client.on("error", onClientError);
+        let heartbeat;
+        let budget;
+        try {
+          await client.query("BEGIN");
+          await client.query("SET LOCAL idle_in_transaction_session_timeout = 0");
+          const lockRows = async () => {
+            const r = await client.query(
+              `SELECT company_id, account_id, actor_id, role, display_name, onboarding_completed_at, onboarding_step
+             FROM ${this.s}.company_members WHERE company_id = $1 FOR UPDATE`,
+              [companyId]
+            );
+            return r.rows.map(rowToMember);
+          };
+          const all2 = await lockRows();
+          const lease = {
+            beginExternalWrite: async () => {
+              const guardFlags = () => {
+                if (sectionEnded) throw new CompanyMembersLockLostError(companyId, "section_ended", false);
+                if (lost) throw new CompanyMembersLockLostError(companyId, lost.reason, false);
+              };
+              guardFlags();
+              let fresh;
+              try {
+                fresh = await lockRows();
+              } catch (err) {
+                lose("connection_lost", err instanceof Error ? err : new Error(String(err)));
+                throw new CompanyMembersLockLostError(companyId, "connection_lost", false);
+              }
+              guardFlags();
+              writeIssued = true;
+              return fresh;
+            }
+          };
+          heartbeat = setInterval(() => {
+            client.query("SELECT 1").catch((err) => lose("connection_lost", err instanceof Error ? err : new Error(String(err))));
+          }, this.membersLockHeartbeatMs);
+          heartbeat.unref?.();
+          budget = setTimeout(() => lose("budget_exceeded"), this.membersLockWriteBudgetMs);
+          budget.unref?.();
+          const running = run(all2, lease);
+          const out = await new Promise((resolve12, reject) => {
+            abandon = reject;
+            if (lost && !writeIssued) reject(new CompanyMembersLockLostError(companyId, lost.reason, false));
+            running.then(resolve12, reject);
+          });
+          if (lost) {
+            throw new CompanyMembersLockLostError(companyId, lost.reason, true);
+          }
+          await client.query("COMMIT");
+          return out;
+        } catch (e) {
+          if (!broken) await client.query("ROLLBACK").catch(() => {
+          });
+          throw e;
+        } finally {
+          sectionEnded = true;
+          if (heartbeat) clearInterval(heartbeat);
+          if (budget) clearTimeout(budget);
+          client.removeListener("error", onClientError);
+          client.release(broken);
+        }
+      }
       // —— 存量身份映射（ADR D3）——
       async migrateSoleCompanyOwner(companyId, toAccountId, audit2) {
         const client = await this.pool.connect();
@@ -262339,6 +262878,16 @@ var init_postgres_control_plane = __esm({
             await client.query("ROLLBACK");
             return { ok: false, reason: "not_pending", current: cur };
           }
+          const seats = await client.query(
+            `SELECT company_id, account_id, actor_id, role, display_name, onboarding_completed_at, onboarding_step
+           FROM ${this.s}.company_members WHERE company_id = $1 FOR UPDATE`,
+            [member.companyId]
+          );
+          const seated = seats.rows.map(rowToMember).find((m2) => m2.accountId === member.accountId);
+          if (seated) {
+            await client.query("ROLLBACK");
+            return { ok: false, reason: "already_member", member: seated };
+          }
           if (Date.parse(cur.expiresAt) <= Date.parse(now)) {
             await client.query(
               `UPDATE ${this.s}.company_invitations SET status = 'expired' WHERE id = $1`,
@@ -262354,10 +262903,20 @@ var init_postgres_control_plane = __esm({
           const inserted = await client.query(
             `INSERT INTO ${this.s}.company_members (company_id, account_id, actor_id, role, created_at, updated_at)
          VALUES ($1,$2,$3,$4,now(),now())
-         ON CONFLICT (company_id, account_id) DO UPDATE SET actor_id = $3, role = $4, updated_at = now()
+         ON CONFLICT (company_id, account_id) DO NOTHING
          RETURNING *`,
             [member.companyId, member.accountId, member.actorId, member.role]
           );
+          if (inserted.rowCount === 0) {
+            const raced = await client.query(
+              `SELECT company_id, account_id, actor_id, role, display_name, onboarding_completed_at, onboarding_step
+             FROM ${this.s}.company_members WHERE company_id = $1 AND account_id = $2`,
+              [member.companyId, member.accountId]
+            );
+            await client.query("ROLLBACK");
+            const current = raced.rows[0] ? rowToMember(raced.rows[0]) : member;
+            return { ok: false, reason: "already_member", member: current };
+          }
           await client.query("COMMIT");
           return { ok: true, invitation: { ...cur, status: "accepted" }, member: rowToMember(inserted.rows[0]) };
         } catch (e) {
@@ -278733,6 +279292,7 @@ __export(src_exports2, {
   ACTOR_DELETED_CHAT_MESSAGE: () => ACTOR_DELETED_CHAT_MESSAGE,
   ACTOR_DELETED_ERROR_CODE: () => ACTOR_DELETED_ERROR_CODE,
   ASSISTANT_ARCHIVED_CODE: () => ASSISTANT_ARCHIVED_CODE,
+  ASSISTANT_BOUND_MESSAGE: () => ASSISTANT_BOUND_MESSAGE,
   ASSISTANT_POSITION: () => ASSISTANT_POSITION,
   ASSISTANT_TIER_RULES: () => ASSISTANT_TIER_RULES,
   AUTOMATION_TEMPLATES: () => AUTOMATION_TEMPLATES,
@@ -278880,6 +279440,7 @@ __export(src_exports2, {
   ORPHANED_TURN_ASSISTANT_NOTICE: () => ORPHANED_TURN_ASSISTANT_NOTICE,
   OUTPUT_COPY_LIMITS: () => OUTPUT_COPY_LIMITS,
   OWNER_PROTECTED_MESSAGE: () => OWNER_PROTECTED_MESSAGE,
+  OWNER_PROTECTED_PROFILE_MESSAGE: () => OWNER_PROTECTED_PROFILE_MESSAGE,
   PARENT_CONVERSATION_PATH: () => PARENT_CONVERSATION_PATH,
   PARENT_CONVERSATION_RECENT_TURNS: () => PARENT_CONVERSATION_RECENT_TURNS,
   PostgresNotificationStore: () => PostgresNotificationStore,
@@ -278939,6 +279500,7 @@ __export(src_exports2, {
   assertMayCreateAgent: () => assertMayCreateAgent,
   assertMayManageAgent: () => assertMayManageAgent,
   assertMaySelfOrManage: () => assertMaySelfOrManage,
+  assistantBoundToMember: () => assistantBoundToMember,
   assistantRowRecovery: () => assistantRowRecovery,
   assistantsDomain: () => assistantsDomain,
   atCapacity: () => atCapacity,
@@ -279302,6 +279864,7 @@ __export(src_exports2, {
   rollbackOrgIdentity: () => rollbackOrgIdentity,
   roundOfMessage: () => roundOfMessage,
   routeFusedSignal: () => routeFusedSignal,
+  runGuardedActorWrite: () => runGuardedActorWrite,
   runtimeConnectionStatus: () => runtimeConnectionStatus,
   runtimeDriftBlock: () => runtimeDriftBlock,
   runtimeSwitchedNotice: () => runtimeSwitchedNotice,
@@ -283211,10 +283774,10 @@ async function startServe(opts) {
        `controlPlaneStore` / `getEngine` / `resolveAssistantsCtx` 在下方才就绪；这三个箭头只在
        请求时跑（同 `projectExists` 的惰性模式）。 */
     agentManageGuard: {
-      callerRole: async (companyId, callerActorId) => {
+      memberRole: async (companyId, actorId) => {
         const cid = companyId ?? defaultCompanyId;
         const members = await controlPlaneStore.listMembers(cid);
-        const row = members.find((m2) => m2.actorId === callerActorId || m2.accountId === callerActorId);
+        const row = members.find((m2) => m2.actorId === actorId || m2.accountId === actorId);
         return row?.role;
       },
       boundHuman: async (companyId, agentId) => {
@@ -283222,6 +283785,27 @@ async function startServe(opts) {
         if (!ctx) return null;
         return (await ctx.service.getByAgent(agentId))?.humanActorId ?? null;
       },
+      /* 删助理那一笔的绑定锁（🔴 R8 阻断项）：与换绑 / 认领 / 回归复用**同一把**——都是助理域
+         那份 bindStore 上按 agent 键的 advisory lock，经 `withAgentBindingLock` 借出（绑定的写面
+         仍只在助理服务里）。和 `boundHuman` 走同一个解析器，所以锁的和读的必然是同一家公司的
+         同一份 store；两处各解析一次就会出现「锁了 A 家的、读了 B 家的」。
+         解析器还没装好（启动期，没有请求）→ 不额外上锁，闸那边仍会重读绑定。 */
+      lockAgentBinding: async (companyId, agentId, run) => {
+        const ctx = await resolveAssistantsCtxLazy(companyId);
+        return ctx ? ctx.service.withAgentBindingLock(agentId, run) : run();
+      },
+      /* 锁内复核（评审阻断①）：借控制面那把成员行锁，把「最终判权 + 那一笔 registry 写入」
+         排进与转交 / 降级 / 移除 / 改昵称同一条队。`roleOf` 读的是**锁内**那份快照，不是
+         上面 memberRole 那一眼；找行的口径与它逐字一致（现阶段 actorId === accountId，
+         但仍两边都比，免得哪天分化后这道闸静默失效）。 */
+      lockMembers: async (companyId, run) => {
+        const cid = companyId ?? defaultCompanyId;
+        const roleOfIn = (members) => (actorId) => members.find((m2) => m2.actorId === actorId || m2.accountId === actorId)?.role;
+        return controlPlaneStore.withCompanyMembersLocked(cid, async (members, lease) => run(
+          roleOfIn(members),
+          { beginExternalWrite: async () => roleOfIn(await lease.beginExternalWrite()) }
+        ));
+      },
       reportsTo: async (companyId, humanActorId) => {
         const engine2 = await getEngine(companyId ?? defaultCompanyId);
         return (await engine2.registry.getActor(humanActorId))?.reportsTo ?? null;
@@ -289674,6 +290258,7 @@ ${nodeFault}` : "");
                   const killed = await tk.killNodeReviews({
                     artifactId: t.artifactId,
                     actor: SYSTEM_ACTOR2,
+                    source: "sla",
                     reviewerActorId: t.actorId,
                     reason: notice
                   });
@@ -294936,7 +295521,7 @@ async function waitForCommandAuthorization(base, headers, draftId, fallback) {
     }
   }
 }
-var CLI_VERSION = "2.2.89" ? "2.2.89" : "dev";
+var CLI_VERSION = "2.2.90" ? "2.2.90" : "dev";
 function apiHeaders(token, company) {
   const headers = {
     authorization: `Bearer ${token}`,
@@ -298907,7 +299492,7 @@ function shimScript() {
 }
 
 // src/index.ts
-var PKG_VERSION = true ? "2.2.89" : "dev";
+var PKG_VERSION = true ? "2.2.90" : "dev";
 var LOCAL_BIN = localBin();
 var NPM_PREFIX = npmPrefix();
 var INSTANCE = DEFAULT_INSTANCE;