@sema-agent/client-core 0.77.1 → 0.77.2

package/dist/workflowClient.js

@@ -1,89 +1,9 @@
-/**
- * ⇄ B6 批搬迁(2026-07-27,设计稿 §3 B6):cli `src/sema/workflowClient.ts` 整搬(依赖面 = SDK + env,
- *    §3 表登记 472 行)。
- *
- * 🔴 搬迁四处差分(端资产上移 / 单一构造点,行为面逐条记账):
- *   ① `new AgentClient({…})` 直造 → `makeEngineWireClient()`(§8-2 定谳的唯一构造点;凭证过
- *      `resolveWireAuth` 三态)。**`maxRetries: 2` 显式传** —— 工厂缺省是 0(raw fetch 单发语义),
- *      而这里原本吃的是 SDK 缺省 2;不显式传就等于**偷偷改了这条观测环路的重试次数**。
- *      唯一残余差分:`authToken` 为**空串**时,原版原样交给 SDK,收编后走三态(loopback ⇒ 零
- *      Authorization 头 / 非 loopback ⇒ 'anon')—— 与另外 11 处构造点同一处置,记在 §8-2。
- *      工厂 fail-soft 返回 null(SDK 拒绝构造)⇒ 本源恒 degraded、`snapshot()` 恒 null,宿主回落
- *      mock/空态 —— 与「501/404/空列表」同一条不抛的路。
- *   ② `process.env.SEMA_DEBUG` → `engineWireDebugEnabled()`;`console.error` → `hostLog('debug', …)`
- *      (本包零 `process`、零 console —— portability 门盯着)。
- *   ③ 投影产物的类型契约(`WorkflowRunState` 族)改 import 本包 `workflowMonitor.ts`(同批搬入),
- *      不再从 TUI 的 `overrides/workflow-detail-dialog.js` 反向依赖渲染件。
- *   ④ `export default createLiveWorkflowSource` **不带过来**:本包是具名导出面(index 做 `export *`,
- *      default 不在其中)。壳侧那一行 default import 若存在,shim 里改具名。
- *
- * ── 以下为原文件的领域说明(逐字保留)────────────────────────────────────────────────────────
- *
- * workflowClient — MF-W LIVE WIRE source (the workflow-monitor TWIN of fleetClient.ts).
- *
- * WHY THIS FILE EXISTS
- * --------------------
- * mock/workflow/workflowRun.ts synthesizes ONE representative WorkflowRunState from a scripted run (offline/
- * demo). This file is its LIVE TWIN: it constructs the @sema-ai/sdk `AgentClient`, consumes the §workflow
- * observability surface shipped in @sema-ai/sdk 0.0.40 (`client.workflows.list/get/stream`, resources/
- * workflows.ts — GET /v1/workflows*, the S8 self-orchestration-observability endpoints), and PROJECTS the
- * SDK's `WorkflowRun` (phases / agents / stats) to the SAME `WorkflowRunState` the reconstructed monitor
- * (src/sema/overrides/workflow-detail-dialog.tsx) already consumes. ZERO renderer change — exactly the
- * fleetClient.ts pattern (a projector, not a port).
- *
- * SDK CONTRACT (resources/workflows.ts + types.ts):
- *   - `list({status?,limit?})` → `{ workflows: WorkflowRunSummary[] }` (OWNER-scoped: only the caller's runs).
- *   - `get(id)`               → full `WorkflowRun` (phases: unknown[] structured {title,status,done,total};
- *                                agents: WorkflowAgentRow[] with activity[].arg; stats.tokens own+nested).
- *   - `stream(id)`            → SSE of `WorkflowStreamEvent` (first frame `meta`, then core WorkflowEvent
- *                                frames). REPLICA-LOCAL + in-process, NOT resumable — a drop is a FULL restart
- *                                (re-`get()` for the snapshot), never a resume.
- *
- * 🔴 GRACEFUL DEGRADE (the load-bearing half — see the mount seam's verification-debt note): the LIVE
- *    endpoints are gated behind the server's S8 (self-orchestration-observability) flag. With S8 OFF the
- *    routes answer **501** (typed APIError) BEFORE any frame; a non-owner / absent run answers **404**; an
- *    owner with no runs yields an **empty** list. ALL THREE are EXPECTED, NOT crashes: this source records
- *    them (status().degraded/code) and keeps `snapshot()` null so the host can fall back to the mock/empty
- *    state. A raw connection error (server down) is treated the same way — the stream/loop just backs off and
- *    retries; the source NEVER throws into the host.
- *
- * 🔴 THE SDK PRODUCES FRAMES, IT DOES NOT MAINTAIN STATE. We take the AUTHORITATIVE snapshot from `get()` and
- *    treat `stream()` as a "something changed" TICKER: on each frame we re-`get()` the owner-scoped detail
- *    (throttled) and re-project, rather than reduce the permissive/core-internal WorkflowEvent shapes on the
- *    client. On stream drop we re-`get()` for a fresh snapshot (not resumable) with a small backoff.
- *
- * DROP-IN SHAPE: `snapshot()` returns the latest projected `WorkflowRunState | null` (null until the first
- * successful `get()`, or while degraded) — the host polls it on an interval and swaps the mock for the live
- * state once one resolves. `dispose()` aborts the stream + stops the background loop on host unmount.
- */
 import { APIError } from '@sema-agent/sdk';
 import { abortableSleep } from './abortableSleep.js';
 import { engineSessionParamSpread } from './engineSessionParam.js';
 import { makeEngineWireClient } from './engineWireSdk.js';
 import { engineWireDebugEnabled } from './engineWireTarget.js';
 import { hostLog } from './host.js';
-// ── SDK WorkflowRun → monitor WorkflowRunState projectors ────────────────────────────────────────────────
-// The SDK shapes (types.ts) are PERMISSIVE (open index sigs). The monitor's WorkflowRunState/Phase/Agent
-// (workflowMonitor.ts) is the 187-faithful consumed set. We read the known fields, coerce
-// the vocabularies, and fill the shell-local render defaults the wire does not carry — same discipline as
-// projectTasks/projectWorkflows in fleet/fleetProjection.ts.
-/**
- * ── `parked` 在这一族投影里的纪律(0.63.1;G-20)────────────────────────────────────────────
- * 「停在审批门上」是一个**说得出口的状态词**,不是一个未知的未来值:那条腿在有人做决定之前
- * **永远不会**自己往前走一步,而 `running` 承诺的恰恰是「等着就好」。⇒ 下面四处窄读一律给它
- * 一条**自己的臂**,开集兜底(未知未来值 → 活跃)一个字节都不动。
- *
- * 三级词表今天各自的真实供给(engine core 7.10.0,亲核):
- *   · **agent 行** —— `WorkflowItemStatus` 含 `parked`(#642),`deriveAgentDisplayStatus` 直接产
- *     `"parked"`(`AgentDisplayStatus` 六词)⇒ 这是**今天就会到**的读数。
- *   · **run 级** —— 仍闭在 running|completed|failed;一条腿 park ⇒ 整只 run 按
- *     `WorkflowAgentParkedError` 收在 `failed` ⇒ `parked` 今天到不了这一位,那条臂是**前向预挂**。
- *   · **phase 级** —— 上游明说「a phase or group never parks」,同为前向预挂;本包另从桶里的腿
- *     **推**出这一格(见 `projectPhases`)。
- */
-/** run status → the monitor's run-level vocabulary. SDK: queued|running|completed|failed|(open). The monitor
- *  run status is running|done|failed|stopped|paused|parked — there is no run-level 'queued', so a queued run
- *  reads as 'running' (the header shows the raw status text anyway; the box treats non-done/failed as active). */
 function coerceRunStatus(s) {
     switch (s) {
         case 'completed':
@@ -93,14 +13,13 @@ function coerceRunStatus(s) {
         case 'running':
             return 'running';
         case 'parked':
-            return 'parked'; // 前向预挂(见上方族头注):词真到了就原样透出,绝不折成「在跑」
+            return 'parked';
         case 'queued':
-            return 'running'; // 无 run 级 queued 词,排队按活跃渲(正向证据:引擎说它在队里)
+            return 'running';
         default:
-            return 'unknown'; // 0.72.12 CC-51(#64 A-28):认不出的词 ⇒ unknown,不渲成「在跑」;壳渲原串 + 未知标
+            return 'unknown';
     }
 }
-/** run 级状态的证据式收口:认得的词照旧;`unknown` 时腿上有活跃证据(start / progress / queued)⇒ `running`。 */
 function runStatusWithLegEvidence(coerced, agents) {
     if (coerced !== 'unknown')
         return coerced;
@@ -109,7 +28,6 @@ function runStatusWithLegEvidence(coerced, agents) {
         return 'running';
     return 'unknown';
 }
-/** detail phase status (service projects {title,status,done,total}) → the monitor's phase vocabulary. */
 function coercePhaseStatus(s) {
     switch (s) {
         case 'done':
@@ -122,16 +40,13 @@ function coercePhaseStatus(s) {
         case 'pending':
             return 'not-started';
         case 'parked':
-            return 'parked'; // 前向预挂,同 coerceRunStatus
+            return 'parked';
         case 'running':
             return 'running';
         default:
-            return 'unknown'; // CC-51:同 coerceRunStatus
+            return 'unknown';
     }
 }
-/** SDK WorkflowAgentRow.status ("the input vocab the display derivation reads", types.ts:352) → the monitor's
- *  AgentState input set (start|progress|queued|done|error|inactive — the WPe INPUT vocabulary the monitor
- *  derives DisplayStatus from). We pass the atlas vocab through and tolerate service display-synonyms. */
 function coerceAgentState(s) {
     switch (s) {
         case 'start':
@@ -141,7 +56,6 @@ function coerceAgentState(s) {
         case 'error':
         case 'inactive':
             return s;
-        // service display-vocab synonyms (should the wire emit them) → the monitor's input state.
         case 'running':
         case 'active':
             return 'progress';
@@ -149,28 +63,14 @@ function coerceAgentState(s) {
             return 'done';
         case 'failed':
             return 'error';
-        // service detail `displayStatus` (core deriveAgentDisplayStatus): `interrupted` = a non-terminal agent
-        // under a terminated run → the monitor's `inactive` input (WPe lands it on 'interrupted' display via
-        // !workflowActive — the run IS terminal whenever core emits this).
         case 'interrupted':
             return 'inactive';
-        // 🔴 core 7.10.0 #642:这条腿耐久挂在一张审批卡上(行上记着 checkpoint token)。**今天就会到**
-        // 的读数(raw `status` 与 `displayStatus` 两条腿都会带),原词透出——折进 `progress` 就是把
-        // 「要人去批」渲成「等它跑完」。
         case 'parked':
             return 'parked';
         default:
-            return 'progress'; // unknown-future live status → render as an active agent (open-set fallback)
+            return 'progress';
     }
 }
-/** Project the bounded activity beats (WorkflowActivityBeat, start/end PAIRS) → the monitor's per-call
- *  WorkflowToolCall[]. The 'start' beat carries the SHORT secret-scrubbed primary-arg summary (types.ts:339);
- *  we fold each tool CALL (keyed by toolCallId) to one row {name, summary?}, keeping the first non-empty arg
- *  as the summary. Beats without a toolName are dropped (heartbeat/partial). Order preserved. */
-/** clay ⑤ 案(2026-07-22 截图定谳):beat.arg 契约上是 SHORT 摘要,但 StructuredOutput 等工具的
- *  主参数=整段多行内容(server 侧 scrub 不折行)——Activity 行渲染用 truncateToWidth 只截宽度
- *  不清换行,首个换行之后的行顶格渲出面板(样式逃框)。数据层单点单行化:取首行,有后续行缀 …;
- *  两个消费点(Activity 行 + lastToolSummary)一并被护。 */
 function oneLineSummary(s) {
     const nl = s.search(/\r?\n/);
     if (nl < 0)
@@ -200,27 +100,16 @@ function projectActivity(beats) {
     }
     return order.map(k => byCall.get(k)).filter((c) => !!c);
 }
-/** one WorkflowAgentRow → the monitor's WorkflowAgent (+ a private `_phase` carrier for phase bucketing). */
 function projectAgent(row, index) {
-    // WorkflowAgentRow carries no TYPED id — read a stable id from the permissive fields, else index-derive.
     const rec = row;
     const id = String(rec.id ?? rec.agentId ?? `agent-${index}`);
     const agentId = typeof rec.agentId === 'string' && rec.agentId ? rec.agentId : id;
-    // Prefer the service detail's `displayStatus` (core's shared deriveAgentDisplayStatus:
-    // queued|running|done|failed|interrupted) over the RAW record `status` (running|completed|failed): the raw
-    // vocabulary carries no queued/interrupted arm — a queued agent's record status is literally 'running', so
-    // coercing `row.status` alone rendered every queued agent as "Running" (the [840] parity gap).
-    // 🔴 空串 = 缺席(0.63.1,G-20 同形存量⑤):`??` 只挡 null/undefined,一个空串的 `displayStatus`
-    //    会把 raw `status` 整个静默吃掉(`'' ?? row.status` === `''`)—— 那条腿真正的状态词连回落
-    //    这条路都走不到。与 `workflow.ts` 两条链路同尺:空串不是读数。
     const displayStatus = typeof rec.displayStatus === 'string' && rec.displayStatus.length > 0 ? rec.displayStatus : undefined;
     const state = coerceAgentState(displayStatus ?? row.status);
     const activity = projectActivity(row.activity);
     const last = activity.length ? activity[activity.length - 1] : undefined;
     const label = typeof row.label === 'string' && row.label.trim() ? row.label.trim() : id || 'agent';
     const agent = { id, agentId, label, state };
-    // #242 批 1:callKey 是 SSE 侧 activity 台账的**主键**(agent_activity 帧必带),此前投影把它丢了
-    // ⇒ 合并层只剩 label 一把钥匙,重名 agent 只能整组跳过。带出来之后重名也能精确归属。
     if (typeof row.callKey === 'string' && row.callKey)
         agent.callKey = row.callKey;
     if (typeof row.model === 'string')
@@ -240,12 +129,6 @@ function projectAgent(row, index) {
         agent.promptPreview = row.prompt;
     if (typeof row.output === 'string')
         agent.resultPreview = row.output;
-    // WPe (agentDisplayStatus) derives queued-vs-running from queuedAt/startedAt on the active path. The service
-    // detail ALWAYS sends `queuedAt` (MF-W 1.150: enqueue time) and sends `startedAt` only once the agent acquired
-    // a concurrency slot — so PASS BOTH THROUGH unconditionally and WPe derives faithfully (queuedAt set +
-    // startedAt absent → 'queued'; both set → 'running'). The old projection dropped queuedAt unless the coerced
-    // state was literally 'queued' (which the raw record vocabulary never produces) — every queued agent lost its
-    // timestamps and rendered 'running'. Synthesize queuedAt only for a wire that says 'queued' without one.
     const startedAt = typeof rec.startedAt === 'number' ? rec.startedAt : undefined;
     const queuedAt = typeof rec.queuedAt === 'number' ? rec.queuedAt : undefined;
     const durationMs = typeof rec.durationMs === 'number' ? rec.durationMs : undefined;
@@ -263,7 +146,6 @@ function projectAgent(row, index) {
     const phase = typeof row.phase === 'string' && row.phase.trim() ? row.phase.trim() : undefined;
     return Object.assign(agent, phase ? { _phase: phase } : {});
 }
-/** read the (permissive) structured phase rows the service detail projects (`{title,status,done,total,…}`). */
 function readPhases(run) {
     const out = [];
     for (const p of run.phases ?? []) {
@@ -284,10 +166,6 @@ function stripPhase(a) {
     void _ignored;
     return rest;
 }
-/** Build the monitor's WorkflowPhase[] from the run's structured phases + the agents' `_phase` tags. Three
- *  paths, all degrade-safe: (1) structured phases on the wire → bucket agents by their phase title (an agent
- *  whose phase matches none lands in the first phase); (2) no structured phases but agents carry phase tags →
- *  one phase per distinct tag; (3) neither → a single synthetic 'Workflow' phase holding every agent. */
 function projectPhases(run, agents) {
     const raw = readPhases(run);
     const firstRaw = raw[0];
@@ -327,8 +205,6 @@ function projectPhases(run, agents) {
     return [
         {
             title: 'Workflow',
-            // 同形第二处(G-20):这条三元式与 `coerceRunStatus` 读的是同一位 run 状态,兜底也同形 ——
-            // 只修一处等于把病搬个家。`parked` 走 `coerceRunStatus` 的同一条臂,不在这里另写一遍判据。
             status: synthPhaseStatus(run.status, agents),
             doneCount: agents.filter(a => a.state === 'done').length,
             totalCount: agents.length,
@@ -336,13 +212,6 @@ function projectPhases(run, agents) {
         },
     ];
 }
-/**
- * 一桶腿 → 这一格的状态词。
- *
- * 🔴 `parked` 的判据是「**这一格里没有一条腿能自己往前走**」:全员不是完成就是停在门上,且至少有
- *    一条真停着。混着还在跑的腿时**仍报 running** —— 那一格确实还在跑,渲成 parked 是另一个方向的谎。
- * 🔴 `failed` 仍先判:一格里既有失败又有停着的腿时,先要人看的是那条失败的。
- */
 function bucketStatus(bucket) {
     if (bucket.some(a => a.state === 'error'))
         return 'failed';
@@ -351,16 +220,10 @@ function bucketStatus(bucket) {
     if (bucket.some(a => a.state === 'parked') && bucket.every(a => a.state === 'parked' || a.state === 'done')) {
         return 'parked';
     }
-    // 0.72.12 CC-51(异源对抗复审 R1 [high];DS-06 病形本体 = 兜底位置落正向词):`running` 只在有腿真在跑 / 排队时说;
-    // 空桶(零腿)与全是 inactive 之类没有活跃证据的桶 ⇒ unknown。上一行的 `length > 0` 守卫做对了「空集 every 恒真」那一格,
-    // 却栽在这个尾 return 上 —— 病不在粗心,在「兜底位置写什么」缺纪律。
     if (bucket.some(a => a.state === 'start' || a.state === 'progress' || a.state === 'queued'))
         return 'running';
     return 'unknown';
 }
-/** 合成 `Workflow` 单格(路径三:wire 既无结构化 phases 也无 agent 上的 phase 标)的状态词。
- *  跟 run 走(同 {@link coerceRunStatus} 的臂),run 说不出 `parked` 时再从腿上推一次 —— 今天真正
- *  会带 `parked` 的正是腿那一级,而路径三的这一格代表的就是整只 run 的全部腿。 */
 function synthPhaseStatus(runStatus, agents) {
     if (runStatus === 'completed')
         return 'done';
@@ -368,28 +231,17 @@ function synthPhaseStatus(runStatus, agents) {
         return 'parked';
     const derived = bucketStatus(agents);
     if (derived === 'parked')
-        return 'parked'; // 腿上的 park 压过 run 级 failed(core 7.10.0 把一条腿 park 收在 failed)
-    // 腿上的 error 是明确失败证据(bucketStatus 失败优先)—— 合成格与带 phase 标签的同组腿必须同判(异源对抗复审 R3)。
+        return 'parked';
     if (runStatus === 'failed' || derived === 'failed')
         return 'failed';
-    // 0.72.12 CC-51(异源对抗复审 R1 [high]):此前尾三元 `failed ? 'failed' : 'running'` 把「run 缺 status / 认不出的词」折成在跑。
-    // 正向证据两处:run 自己说 running / queued,或腿上有人在跑;都没有 ⇒ unknown。
     if (runStatus === 'running' || runStatus === 'queued')
         return 'running';
     return derived === 'running' ? 'running' : 'unknown';
 }
-/** THE projector: SDK `WorkflowRun` (client.workflows.get) → the monitor's `WorkflowRunState`. Pure/total —
- *  tolerates absent/permissive fields and never throws (the graceful-degrade contract lives above, in the
- *  source loop; this just maps a well-formed run). Exported for the mock-parity unit cross-check. */
 export function projectWorkflowRun(run) {
     const parks = readWorkflowParks(run);
     const agents = (run.agents ?? []).map((r, i) => projectAgent(r, i));
     const phases = projectPhases(run, agents);
-    // 0.73.0:总用量三态 —— 有键 ⇒ 一个**完整**的总数(含真 0);缺键 ⇒ 没有完整总数。判据(每个分量都先验非负整数):
-    //   ① 引擎聚合 `stats.tokens` 在场且合法:无 nested 载体 ⇒ 就是它;nested 载体在场 ⇒ 其 tokens 也得合法才相加,否则缺席
-    //      (残缺的聚合不按 0 补齐 —— 那会发布一个偏小的「总数」);
-    //   ② `stats.tokens` 缺席但 nested 载体在场 ⇒ 聚合残缺 ⇒ 缺席(不退到腿上求和:腿只覆盖本 run,会把嵌套的那部分漏掉);
-    //   ③ 两者都没有 ⇒ 退到腿上求和,但只在**每条腿都报过合法用量**且至少一条腿时成立;有腿未报 / 非法 / 零条腿 ⇒ 缺席。
     const validTokens = (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0 ? v : undefined;
     const ownTokens = validTokens(run.stats?.tokens);
     const nestedCarrier = run.stats?.nested;
@@ -409,16 +261,9 @@ export function projectWorkflowRun(run) {
                 : undefined;
     const state = {
         workflowRunId: run.id,
-        // 0.72.12 CC-51(异源对抗复审 R2 [medium]):run 状态词认不出 / 缺席时先看腿上的**活跃证据** —— 有腿在跑 / 排队 ⇒ running
-        // (老壳用 `status === 'running'` 算 workflowActive,run 落 unknown 会把明明在跑的腿渲成 Stopped);零证据才 unknown。
-        // 不拿「腿全做完了」反推 run 完成:那是 run 自己的话。
         status: runStatusWithLegEvidence(coerceRunStatus(run.status), agents),
-        // CC-12(0.69.1):park 两新键**进视图**(修前只出读器,端拿不到裸体 ⇒ 渲染面结构性造不出);铸法与缺席律逐字同两读器。
         ...(parks !== undefined ? { parks } : {}),
         ...(readWorkflowResumeAdmissionIncomplete(run) ? { resumeAdmissionIncomplete: true } : {}),
-        // The authored script TEXT is not projected to the wire (types.ts:375 — service does not emit it), so leave
-        // it empty: the monitor's "save script" affordance stays off (canSave = script.length > 0). Never fabricate
-        // a script we do not have. scriptPath is likewise absent until the service projects it.
         script: '',
         agentCount: agents.length,
         ...(totalTokens !== undefined ? { totalTokens } : {}),
@@ -430,18 +275,6 @@ export function projectWorkflowRun(run) {
         state.description = run.description;
     return state;
 }
-/**
- * `GET /v1/workflows/:id` 的 `parks[]` → 三键行;**整键缺席 ⇒ `undefined`**(与空数组逐字可分)。
- *
- * 🔴 **`undefined` 与 `[]` 不是一回事**,这是本读器最承重的一格:
- *    · `undefined` —— 这条记录上没有 `parks` 这一键(旧引擎写的)⇒ **证不出**有没有 park;
- *    · `[]`        —— 这条记录有这一键且是空的 ⇒ 一句正面事实:这条 run 上没有 park。
- * 🔴 **坏行只丢自己**(与本包 `wiring_manifest.mcp[]` 的处置同尺):三键缺一 / 非串 / 空串 的行
- *    整条丢弃,其余行保序留下;**非空输入而全部坏行 ⇒ 返回 `[]`**?—— **不**:那会把「读不出」
- *    伪装成「零 park」。全坏 ⇒ `undefined`(诚实缺席)。
- * 🔴 `parks` 不是数组(对象 / 串 / null)⇒ 当整键缺席(非投影口喂进来的形)。
- * 🔴 纯函数、零副作用、**绝不抛**。
- */
 export function readWorkflowParks(run) {
     if (typeof run !== 'object' || run === null || Array.isArray(run))
         return undefined;
@@ -458,82 +291,25 @@ export function readWorkflowParks(run) {
         const originRunId = typeof o.originRunId === 'string' && o.originRunId.length > 0 ? o.originRunId : undefined;
         if (callKey === undefined || sessionId === undefined || originRunId === undefined)
             continue;
-        // 🔴 **逐键铸**,不 spread:上游在这张行上多放一个键(尤其是凭据形)时,它在结构上到不了
-        //    本包的产物。这不是风格选择 —— 它是本段 ① 那条红线的实现。
-        // 7.18.0:第四键 never-false,严格 `true` 才铸(`false`/`"true"`/`1` 都是坏值 = 缺席 = 已确认)。
         rows.push({ callKey, sessionId, originRunId, ...(o.originUnconfirmed === true ? { originUnconfirmed: true } : {}) });
     }
-    // 非空输入而一行都没活下来 ⇒ 读不出,不是「零 park」(绝不铸 `[]` 冒充一句正面事实)。
     if (raw.length > 0 && rows.length === 0)
         return undefined;
     return rows;
 }
-/**
- * `GET /v1/workflows/:id` 的 `resumeAdmissionIncomplete`(core 7.18.0 #755,0.68.3 CC-05)——
- * 「这条 resume run 的准入**没有完成**」:记录从创建起带 `true`,准入完成那一刻**删键**。
- *
- * 🔴 **在场 = 不是 resume 基**(引擎自己会拒 `workflow.park_truth_unreadable` / `admission_incomplete`,
- *    且不从它派生候选);缺席 = 每条非 resume run 与每次完成了的准入的常态。⇒ 读者只认在场,
- *    缺席不是断言。never-false:严格 `true` 才算在场,其余一律缺席。
- * 🔴 与 {@link readWorkflowParks} **同一条投影义务**(core 顶注逐字:dropping it turns a refused record
- *    back into an admissible one)—— 端渲 resume 候选 / 面板行时**必须**带上这一位;本包不把它折进
- *    `parks` 的缺席(那一形有自己的两义,见 `readWorkflowParks` 顶注)。
- * 🔴 纯函数、零副作用、绝不抛;坏载体 ⇒ `false`(不是「读不出」:这一位没有第三态)。
- */
 export function readWorkflowResumeAdmissionIncomplete(run) {
     if (typeof run !== 'object' || run === null || Array.isArray(run))
         return false;
     return run.resumeAdmissionIncomplete === true;
 }
-// ── 轮询/退避节拍(REF-CC-131,域词表-15):三个 3000ms 常量语义各不相同,拆开命名——合并成一个
-// 会把三条独立的退避策略绑死在一起(其中任一策略调优都会误伤另外两条)。──────────────────────
-/** owner 名下暂无任何 run(`resolveRunId` 回 null)时的重试间隔:不是错误,只是「还没有可监的
- *  run」——退避到下一次 list() 重试,给一个正在被启动的 run 留出出现的时间。 */
 const NO_RUN_BACKOFF_MS = 3000;
-/** `refresh()` 判定 degraded(501 S8-off / 404 gone)后的重试间隔:不再尝试 stream(),直接退避
- *  重跑外层循环——与 NO_RUN_BACKOFF_MS 数值巧合相同但触发条件不同(有 run id 但拿不到快照)。 */
 const DEGRADED_BACKOFF_MS = 3000;
-/** consume() 外层 catch 兜到的未归类异常(list/refresh 之外的意外)后的退避间隔——保守值,
- *  与前两个 3000 又是同一个数字、不同的触发路径,故各自具名而非合一常量。 */
 const UNEXPECTED_ERROR_BACKOFF_MS = 3000;
-/** stream() 以「无终帧」收场(丢连,非可续传)之后、重新 re-`get()` 快照前的退避间隔——比另外
- *  三个短,因为这是「已知在连接一个存在的 run」而不是「不确定还有没有事可做」。 */
 const STREAM_DROP_BACKOFF_MS = 1000;
-/** stream() ticker 帧触达时,距上一次 `refresh()` 的最小间隔——节流 re-GET 频率,不是退避:
- *  帧到来表示「有变化」,但没必要每一帧都打一次权威快照。 */
 const REFRESH_THROTTLE_MS = 400;
-// ══ #242 批 1(台账 A-028.8)—— 运行期 activity 台账:模块级常驻 + 每 workflowId 恰一条 SSE ═══
-//
-// ── 修前的两半(组合 = 同一 workflowId 上两条 SSE、两份台账)────────────────────────────────
-// ① core:workflow run 记录的 `agents[].toolCalls` / `agents[].activity` **只在 agent_end 折入**
-//    ⇒ 运行中 agent 的 GET 详情永远拿不到工具信息;运行期的工具事实**只在** detail SSE 上
-//    (`agent_activity` 带 callKey/label/toolName/arg/phase/ts;`agent_end` 带权威 toolCalls;
-//     `agent_end.modelResolved` 更是 core 记录从不折入的量 —— SSE 是唯一到达路径)。
-// ② 本文件:把这条 SSE 只当**变化 ticker**(`for await (const _frame …) { void _frame }`),帧体整丢。
-// ⇒ 壳(sema-cli `workflowLiveActivity.ts`)只好**另起一条同 id 的 SSE**自建模块级台账再自己合并。
-//
-// ── 本段(单流化)──────────────────────────────────────────────────────────────────────────
-// 台账收进包内,并且成为该 workflowId 的**唯一 SSE 属主**:
-//   · `ensureWorkflowActivityLedger(cfg)` —— **预热口**(幂等):fleet 流上 workflow 行一出现就调,
-//     从 workflow 起跑积累工具事实。🔴 台账是**模块级常驻**而非 per-controller —— 这是刻意的:
-//     壳侧一版做成「开 monitor 才开流」,实测两个洞(打开前的 beat 全丢:monitor 刚开的头几秒
-//     stats 恒空;重开 monitor = 新流 = 账本清零失忆)。`createLiveWorkflowSource().dispose()`
-//     只收它自己的 GET 循环,**不掐台账**,两个洞因此不会随上收复发。
-//   · `createLiveWorkflowSource` 不再自开流,改搭台账的 change-tick 做节流 re-GET(逐拍等价)。
-//   · `readWorkflowActivityLedger(id)` —— 台账读口(端侧合并层消费:壳 `mergeSnapshot` 只补
-//     base 缺席的键)。归属钥匙 **callKey 优先**(agent_activity 帧必带、GET 行也带),
-//     label 次之;同 label 多个非 replay 的 agent_start ⇒ 归属不可判 ⇒ label 读口**整组跳过**
-//     (诚实缺席,绝不猜挂)。
-// 限界(如实):台账自预热口首次调用起积累 —— 壳自己没看过的时段(重启后 attach 老 run)仍是
-// 下界;`agent_end.toolCalls` 到手后计数转权威。
-/** detail 页 Activity 尾窗是 3(HIO),折叠上限给足余量即可;超限丢最老(与 server 存储折入同向)。 */
 const MAX_WORKFLOW_ACTIVITY_CALLS = 40;
-/** 常驻台账上限(并发运行的 workflow 数远小于此;超限先逐已收口的,再逐最老)。 */
 const MAX_WORKFLOW_ACTIVITY_LEDGERS = 16;
-/** 运行中的意外断流回退(终态收口是**干净空流**自然退出,不再重连)。 */
 const WORKFLOW_ACTIVITY_RECONNECT_MS = 1500;
-/** 「一帧都没收到就抛」的连续次数上限 —— 满了才收口。1 次即收口会把瞬时不可达固化成永久失活;
- *  不设上限则 S8 关闭(恒 501)的部署上会无限重连。3 次 ≈ 3s 观察窗,两头都不失守。 */
 const MAX_ACTIVITY_STREAM_ERROR_STREAK = 3;
 const activityLedgers = new Map();
 function newActivityLedger(workflowId, scope) {
@@ -561,7 +337,6 @@ function newActivityLedger(workflowId, scope) {
         viewLastError: null,
     };
 }
-/** 连线身份相等:凭证只比较、不落键不落日志。relay 形按 mode 比。 */
 function sameActivityScope(a, b) {
     if (a.baseUrl !== b.baseUrl)
         return false;
@@ -585,8 +360,6 @@ function registerLabelAcc(l, label, acc) {
     if (!accs.includes(acc))
         accs.push(acc);
 }
-/** label 位是否**唯一可判**:恰一个 acc、且没被重名探测标记。两条缺一不可 —— 前者盖住
- *  「中途 attach 只见 beat」「replayed 重跑」这两条不经 agent_start 的产生路径,后者是显式诊断位。 */
 function soleAccOfLabel(l, label) {
     if (l.ambiguous.has(label))
         return undefined;
@@ -595,15 +368,10 @@ function soleAccOfLabel(l, label) {
         return undefined;
     return accs[0];
 }
-/** callKey 在场:它是主键。同 label 已有一条**尚未绑 callKey** 的 acc(agent_start 无 callKey 在先)
- *  ⇒ 认领它,不新建第二份;否则新建并登记。 */
 function accByCallKey(l, callKey, label) {
     const hit = l.byCallKey.get(callKey);
     if (hit)
         return hit;
-    // 🔴 只认领「还没被 label-only 的 agent_end 写过权威事实」的 orphan —— 带事实的那种一旦认领,
-    //    另一个 agent 的 toolCalls/modelResolved 就永久钉在这个 callKey 上了(callKey 读口不过
-    //    重名过滤)。不认领时新建第二份 ⇒ 该 label 变成非唯一 ⇒ label 读口自动改口诚实缺席。
     const orphan = (l.labelAccs.get(label) ?? []).find(a => a.callKey === undefined && a.hasLabelOnlyEndFacts !== true);
     const acc = orphan ?? newActivityAcc(label);
     acc.callKey = callKey;
@@ -611,9 +379,6 @@ function accByCallKey(l, callKey, label) {
     registerLabelAcc(l, label, acc);
     return acc;
 }
-/** 只有 label 的写入(`agent_end` 帧不带 callKey)。🔴 该 label 下不止一个 acc ⇒ **不记**
- *  ——错值比缺席更坏:写进去会被 callKey 读口原样读出来,把另一个 agent 的权威 toolCalls/
- *  modelResolved 冒充成这一个的(对抗复审 [high] 采纳)。 */
 function accByLabelForWrite(l, label) {
     const accs = l.labelAccs.get(label);
     if (accs && accs.length > 1)
@@ -626,7 +391,6 @@ function accByLabelForWrite(l, label) {
     registerLabelAcc(l, label, acc);
     return acc;
 }
-/** 一帧 → 台账。开集帧形:只读认得的键,其余原样忽略(不认得的 event 直接落空)。 */
 function foldWorkflowActivityFrame(l, frame) {
     l.frames += 1;
     if (frame.event === 'agent_start') {
@@ -635,7 +399,6 @@ function foldWorkflowActivityFrame(l, frame) {
             return;
         const n = (l.startedLabels.get(label) ?? 0) + 1;
         l.startedLabels.set(label, n);
-        // 重跑(replayed)不算重名;同 label 第二个非 replay start ⇒ 归属不可判。
         if (n > 1 && frame.data.replayed !== true)
             l.ambiguous.add(label);
         const callKey = frame.data.callKey;
@@ -653,7 +416,6 @@ function foldWorkflowActivityFrame(l, frame) {
         const label = frame.data.label;
         if (typeof label !== 'string' || !label)
             return;
-        // agent_end 帧**不带 callKey**(wire 直证)⇒ 只有 label 一把钥匙;重名时不记。
         const acc = accByLabelForWrite(l, label);
         if (!acc)
             return;
@@ -694,7 +456,6 @@ function foldWorkflowActivityFrame(l, frame) {
         folded.summary = arg;
     if (!acc.calls.has(key)) {
         acc.order.push(key);
-        // 上限:丢最老(order 与 map 同步),detail 尾窗只看最近几条。
         while (acc.order.length > MAX_WORKFLOW_ACTIVITY_CALLS) {
             const drop = acc.order.shift();
             if (drop !== undefined)
@@ -710,7 +471,6 @@ function projectActivityAcc(acc) {
         .map(c => ({ name: c.name, ...(c.summary ? { summary: c.summary } : {}) }));
     const view = {
         label: acc.label,
-        // agent_end 的权威值优先,否则 start 计数下界。
         toolCalls: acc.endedToolCalls ?? acc.startCount,
         activity,
     };
@@ -730,8 +490,6 @@ function projectActivityAcc(acc) {
         view.lastProgressAt = acc.lastTs;
     return view;
 }
-/** 台账读口:没有该 id 的台账 ⇒ **null**(不是空视图 —— 「没开过账」与「开了账但一帧没收到」
- *  是两件事,端侧据此分辨)。产物只读,按 frames/closed 缓存。 */
 export function readWorkflowActivityLedger(workflowId) {
     const l = activityLedgers.get(workflowId);
     if (!l)
@@ -756,8 +514,6 @@ export function readWorkflowActivityLedger(workflowId) {
         byCallKey.set(k, viewOf(acc));
     const byLabel = new Map();
     for (const label of l.labelAccs.keys()) {
-        // 🔴 归属不可判(同 label 多个 acc / 重名探测命中)⇒ 整组跳过(诚实缺席,绝不猜挂)。
-        //    callKey 读口不受影响 —— 它才是真钥匙。
         const sole = soleAccOfLabel(l, label);
         if (!sole)
             continue;
@@ -777,7 +533,6 @@ export function readWorkflowActivityLedger(workflowId) {
     l.viewLastError = l.lastError;
     return l.view;
 }
-/** 一拍。一个抛异常的订阅者不许弄死后台消费循环(与本源全篇 fail-soft 一致)。 */
 function emitActivityTick(l) {
     for (const t of [...l.ticks]) {
         try {
@@ -790,7 +545,6 @@ function emitActivityTick(l) {
         }
     }
 }
-/** 等下一拍:'tick' = 有帧到达 / 'closed' = 台账收口 / 'abort' = 宿主 dispose。 */
 function waitActivityTick(l, signal) {
     if (signal.aborted)
         return Promise.resolve('abort');
@@ -812,9 +566,7 @@ function waitActivityTick(l, signal) {
         signal.addEventListener('abort', onAbort, { once: true });
     });
 }
-/** 台账的 SSE 消费循环 —— **该 workflowId 唯一的一条流**。 */
 async function consumeWorkflowActivity(l, cfg) {
-    // 唯一构造点 + 显式 maxRetries: 2(与 createLiveWorkflowSource 同口径)。
     const client = makeEngineWireClient({
         baseUrl: cfg.baseUrl,
         ...(cfg.authToken ? { token: cfg.authToken } : {}),
@@ -822,7 +574,6 @@ async function consumeWorkflowActivity(l, cfg) {
         maxRetries: 2,
         ...(cfg.fetchImpl ? { fetchImpl: cfg.fetchImpl } : {}),
     });
-    // fail-soft:工厂造不出 client ⇒ 台账收口、读口如实报 closed(绝不抛进宿主)。
     if (client === null) {
         l.closed = true;
         l.closedReason = 'error';
@@ -847,7 +598,6 @@ async function consumeWorkflowActivity(l, cfg) {
                     foldWorkflowActivityFrame(l, frame);
                 }
                 catch {
-                    // 单帧折叠失败不拆流(开集帧形;台账缺一拍好过整层失效)。
                 }
                 emitActivityTick(l);
             }
@@ -862,13 +612,6 @@ async function consumeWorkflowActivity(l, cfg) {
             }
         }
         l.connected = false;
-        // 🔴 两种「本轮零帧」必须分开裁(对抗复审 [high] 采纳 —— 合并成一条会把**一次瞬时不可达**
-        //    固化成台账永久失活,而 ensure 对已存在台账恒早退 ⇒ 引擎恢复后 SSE 再也开不回来,
-        //    详情页此后只剩 GET 轮询,而运行期 tool/activity 恰恰是 GET 结构上给不出的量):
-        //    · **干净空流**(迭代器正常结束、一帧没有)= run 终态/不在本副本(core subscribeWorkflow
-        //      非活跃即空迭代器)⇒ 收口,GET 此后是权威;
-        //    · **抛在首帧前**(501/404/连接失败)= 可能只是这一拍不可达 ⇒ 退避重连,连击满
-        //      MAX_ACTIVITY_STREAM_ERROR_STREAK 次(全程零帧)才收口,lastError 留痕。
         if (!sawFrame && !threw) {
             l.closed = true;
             l.closedReason = 'terminal';
@@ -880,7 +623,6 @@ async function consumeWorkflowActivity(l, cfg) {
         else if (threw) {
             l.errorStreak += 1;
             if (l.errorStreak >= MAX_ACTIVITY_STREAM_ERROR_STREAK) {
-                // 🔴 只是「连不上」⇒ 标 error(可被下一次 ensure 重开),不是终态。
                 l.closed = true;
                 l.closedReason = 'error';
                 emitActivityTick(l);
@@ -894,10 +636,6 @@ async function consumeWorkflowActivity(l, cfg) {
     }
     emitActivityTick(l);
 }
-/**
- * **预热口**(幂等):fleet 流上见到 running workflow 行就调 —— 从 workflow 起跑积累工具事实,
- * monitor 无论何时打开都有自那时起的完整台账。已有台账(哪怕已收口)即早退,**绝不开第二条流**。
- */
 export function ensureWorkflowActivityLedger(cfg) {
     if (!cfg.workflowId)
         return;
@@ -908,13 +646,9 @@ export function ensureWorkflowActivityLedger(cfg) {
     };
     const existing = activityLedgers.get(cfg.workflowId);
     if (existing) {
-        // 测试钩建的离线台账:恒早退(不换、不起流)。
         if (existing.testOnly)
             return;
         if (sameActivityScope(existing.scope, scope)) {
-            // 🔴 同连线身份:只有**因错误**收口的才重开(对抗复审 R2 [high] 采纳)——干净空流(run
-            //    终态)与显式 stop 是永久收口,重开等于跟一个已经结束的 run 死磕。重开**复用同一条
-            //    台账对象**,已积累的事实原样保留(重连不失忆)。
             if (existing.closed && existing.closedReason === 'error') {
                 existing.closed = false;
                 existing.closedReason = null;
@@ -924,9 +658,6 @@ export function ensureWorkflowActivityLedger(cfg) {
             }
             return;
         }
-        // 🔴 同 id 但**连线身份变了**(换引擎 baseUrl / 换 principal / 换凭证)⇒ 旧台账连的是另一台
-        //    服务,复用它等于把上一处的活动事实当成这一处的。整条换新,并给旧的打 displaced ——
-        //    旧台账的消费者据此**不再重新 ensure**(否则两个不同 scope 的消费者会互相把槽位换来换去)。
         existing.closed = true;
         existing.closedReason = 'stopped';
         existing.displaced = true;
@@ -935,12 +666,6 @@ export function ensureWorkflowActivityLedger(cfg) {
         activityLedgers.delete(cfg.workflowId);
     }
     if (activityLedgers.size >= MAX_WORKFLOW_ACTIVITY_LEDGERS) {
-        // 逐出顺序:① 已收口的(数据只读,重开 monitor 走 GET 权威)→ ② 无在飞消费者的最老一条。
-        // 🔴 判活用**消费者租约** `consumers` 而不是瞬时的 `ticks.size`(对抗复审 R2 [medium]):
-        //    消费者被一帧唤醒、正在跑一发慢 GET 的那一窗里 ticks 是空的,按它判会把在飞台账逐掉。
-        // 🔴 **绝不逐出正在被消费的台账**:那会当场丢掉它积累的 SSE-only 历史,而被叫醒的消费方
-        //    退避后又会重建、再逐掉另一条在飞的 —— 逐出/重连自激。
-        // 全 16 条都有在飞消费者时**不建新账**(如实降级:该 id 的详情页退回 GET 轮询)。
         let victim;
         for (const [id, other] of activityLedgers) {
             if (other.closed && other.consumers === 0) {
@@ -975,7 +700,6 @@ export function ensureWorkflowActivityLedger(cfg) {
     activityLedgers.set(cfg.workflowId, ledger);
     void consumeWorkflowActivity(ledger, cfg);
 }
-/** fleet 行终态/remove 的收口口(空流收口是主径;这里防重连定时器竞态)。数据保留只读。 */
 export function stopWorkflowActivityLedger(workflowId) {
     const l = activityLedgers.get(workflowId);
     if (!l)
@@ -985,7 +709,6 @@ export function stopWorkflowActivityLedger(workflowId) {
     l.abort.abort();
     emitActivityTick(l);
 }
-/** 测试钩:清空全部台账(abort 在飞流)。 */
 export function resetWorkflowActivityLedgers() {
     for (const l of activityLedgers.values()) {
         l.closed = true;
@@ -995,11 +718,6 @@ export function resetWorkflowActivityLedgers() {
     }
     activityLedgers.clear();
 }
-/**
- * 测试钩:**不起 SSE 流**,直接把一帧喂进(缺则新建)指定 run 的台账 —— 折叠规则走产品那一份
- * `foldWorkflowActivityFrame`,不是测试自己抄一份。建出来的台账是 closed 的,后续
- * `ensureWorkflowActivityLedger` 命中它即早退,离线单测因此永不触网。
- */
 export function __feedWorkflowActivityFrameForTests(workflowId, frame) {
     let l = activityLedgers.get(workflowId);
     if (!l) {
@@ -1009,23 +727,11 @@ export function __feedWorkflowActivityFrameForTests(workflowId, frame) {
         l.closedReason = 'stopped';
         activityLedgers.set(workflowId, l);
     }
-    // 🔴 只往**离线台账**里喂(对抗复审 R2 [medium] 采纳):这个钩虽在 `_` 前缀的测试钩面上
-    //    (不进公开导出基线),但它此前能把伪造帧折进一条**真在跑**的台账。现在真台账一律拒绝
-    //    —— 测试要用它必须先 `resetWorkflowActivityLedgers()`,离线契约从「靠调用方自觉」变成结构。
     if (!l.testOnly)
         return;
     foldWorkflowActivityFrame(l, frame);
     emitActivityTick(l);
 }
-/**
- * createLiveWorkflowSource({ baseUrl, authToken, principal, workflowId? }) — the LIVE workflow-monitor source.
- *
- * Constructs the AgentClient and kicks off a background loop that (1) resolves a run id (explicit config, else
- * the first running run from `list()`), (2) snapshots it via `get()` → project → store, and (3) follows
- * `stream()` as a change-ticker (re-`get()` throttled on each frame). Every step is degrade-safe: a 501 (S8
- * off) / 404 (non-owner/absent) / empty list / connection error is RECORDED (status().degraded/code) and
- * leaves `snapshot()` null so the host falls back to the mock/empty state — the source never throws into it.
- */
 export function createLiveWorkflowSource(config) {
     let current = null;
     let connected = false;
@@ -1035,14 +741,10 @@ export function createLiveWorkflowSource(config) {
     let lastError = null;
     let disposed = false;
     let lastGetAt = 0;
-    /** 入场打点用:只有第一发 get 是「入场」,后续都是 ticker 触发的 re-GET。 */
     let first = true;
-    /** CC-38:list 空(owner 零 run)与 client 造不出来 在 status() 上同形(degraded=true, code=null),用相位分开。 */
     let phase = 'loop';
-    /** 台账槽位被别的连线身份顶掉过 ⇒ 本源放弃 activity 腿(防两个 scope 互相换账)。 */
     let activityDisabled = false;
     const listeners = new Set();
-    /** 通知订阅者「快照变了」。一个抛异常的订阅者不许弄死后台消费循环(fail-soft 与本源全篇一致)。 */
     function notify() {
         if (disposed)
             return;
@@ -1057,7 +759,6 @@ export function createLiveWorkflowSource(config) {
             }
         }
     }
-    // 差分① 见头注:唯一构造点 + 显式 maxRetries: 2(= 收编前吃的 SDK 缺省;工厂缺省 0 是单发探针语义)。
     const client = makeEngineWireClient({
         baseUrl: config.baseUrl,
         ...(config.authToken ? { token: config.authToken } : {}),
@@ -1066,17 +767,7 @@ export function createLiveWorkflowSource(config) {
         ...(config.fetchImpl ? { fetchImpl: config.fetchImpl } : {}),
     });
     const abort = new AbortController();
-    /** record a degrade/error WITHOUT throwing: 501 (S8 off) / 404 (non-owner|absent) are EXPECTED degrades;
-     *  anything else (connection refused, parse) is a soft error — either way the host keeps the mock/empty.
-     *
-     * REF-CC-153(midband-01,fix-outright):the non-APIError branch must explicitly clear `code`/`degraded`
-     * rather than leave a prior call's values sitting there — `status().code` is documented as "the HTTP
-     * status behind a degrade (501/404), else null", so a stale 404 surviving into a later connection-refused
-     * error would misreport an unrelated failure as "still a 404 (run gone)".
-     */
     function noteDegrade(err) {
-        // CC-38(复审实抓):empty 相位只对「刚刚那次 list 为空」成立,之后任何失败都要退回 loop —— 否则一次空表之后的连接故障
-        //   会被 resolution() 一直报成「零 run」,而 status() 早已换成新的 lastError。
         if (phase === 'empty')
             phase = 'loop';
         connected = false;
@@ -1094,14 +785,6 @@ export function createLiveWorkflowSource(config) {
             hostLog('debug', `[sema][workflow] degrade/err (host falls back to mock/empty): ${lastError}`);
         }
     }
-    /**
-     * resolve the run id to monitor: explicit config → the first RUNNING run → the first run → null (empty).
-     *
-     * ⚠️ 入场热路径记账(#79 串行普查):`config.workflowId` 在场时**直接返回,不打 list()** —— 三个
-     * 面板宿主(FleetView 内联 / `/workflows` / footer 内联)都是从 fleet 行拿到 id 才开的,所以入场
-     * 只有 **get 一跳**;list→get 的两跳串行只发生在 `SEMA_SCENARIO=workflow` 独立宿主且未给
-     * SEMA_WORKFLOW_ID 的路径上(那条路没有行可依,list 是唯一的 id 来源 —— 必须串行)。
-     */
     async function resolveRunId(signal) {
         if (config.workflowId)
             return config.workflowId;
@@ -1114,13 +797,10 @@ export function createLiveWorkflowSource(config) {
             return null;
         const running = workflows.find(w => w.status === 'running');
         const firstWorkflow = workflows[0];
-        // `workflows.length > 0` above guarantees index 0 exists; noUncheckedIndexedAccess can't see that,
-        // so re-check explicitly rather than reach for a non-null assertion.
         if (firstWorkflow === undefined)
             return null;
         return (running ?? firstWorkflow).id;
     }
-    /** take the authoritative snapshot + project it; records degrade on failure (never throws). */
     async function refresh(id, signal) {
         const t0 = Date.now();
         try {
@@ -1134,11 +814,9 @@ export function createLiveWorkflowSource(config) {
             code = null;
             lastError = null;
             if (engineWireDebugEnabled()) {
-                // 入场打点(#79):first=true 的那一行就是「壳拿到第一份权威快照」的耗时。
                 hostLog('debug', `[sema][workflow][perf] get ${Date.now() - t0}ms first=${first} agents=${current.agentCount} phases=${current.phases.length}`);
             }
             first = false;
-            // 解析即通知(首帧不等宿主的 1s tick;后续每次 re-project 同样通知,SSE ticker 的 re-GET 也走这里)。
             notify();
         }
         catch (err) {
@@ -1147,15 +825,13 @@ export function createLiveWorkflowSource(config) {
             noteDegrade(err);
         }
     }
-    /** background loop: resolve → snapshot → follow the stream (re-get on frames), degrade-safe throughout. */
     async function consume() {
         while (!disposed && !abort.signal.aborted) {
             try {
                 const id = runId ?? (await resolveRunId(abort.signal));
                 if (id !== null && phase === 'empty')
-                    phase = 'loop'; // 名单从空变非空:还没 get 成功之前先回 pending,不再报 empty
+                    phase = 'loop';
                 if (!id) {
-                    // owner has no runs → empty/degraded (not an error). Back off and re-poll (a run may appear).
                     degraded = true;
                     code = null;
                     phase = 'empty';
@@ -1164,21 +840,11 @@ export function createLiveWorkflowSource(config) {
                     continue;
                 }
                 await refresh(id, abort.signal);
-                // snapshot degraded (501 S8-off / 404 gone) → don't attempt the stream; back off and retry.
                 if (degraded) {
                     await abortableSleep(DEGRADED_BACKOFF_MS, abort.signal);
                     continue;
                 }
-                // 🔴 #242 批 1 单流化:本源**不再自开 SSE**。该 workflowId 的唯一 SSE 属主是模块级 activity
-                // 台账(同时也是 fleet 行预热腿的属主);本源只搭它的 change-tick 做节流 re-GET —— 与旧
-                // `for await (const _frame of stream)` 的逐拍语义等价,而连接数从「壳一条 + 本源一条」降到 1。
-                // 帧体不再被丢弃:台账消费它(callKey 折叠 / agent_end.toolCalls 权威 / requested-resolved model)。
                 if (!activityDisabled) {
-                    // 🔴 停手检查必须先于 ensure(主会话收货修,#242-E13 抓出的时序洞):循环尾的
-                    //    `ledger.displaced` 检查读的是「本轮拿的对象」,而被顶掉发生在上一轮的 backoff 期
-                    //    ——下一轮若先 ensure,本源会在检测到自己被顶之前就把别的连线身份的台账换掉
-                    //    (伤害先于检测,ping-pong 防护形同虚设)。所以进入 ensure 前先看当前槽位:
-                    //    已被**另一连线身份**持有 ⇒ 本源就地停手降级(GET 轮询),绝不抢回。
                     const cur = activityLedgers.get(id);
                     if (cur &&
                         !cur.testOnly &&
@@ -1204,8 +870,6 @@ export function createLiveWorkflowSource(config) {
                 }
                 const ledger = activityDisabled ? undefined : activityLedgers.get(id);
                 if (ledger) {
-                    // 🔴 消费者租约:整段消费期持有(不是瞬时的 tick 订阅)—— 逐出判活读的就是它,
-                    //    「被一帧唤醒、正在跑慢 GET」的那一窗里台账不会被误判成无人消费。
                     ledger.consumers += 1;
                     try {
                         for (;;) {
@@ -1218,8 +882,6 @@ export function createLiveWorkflowSource(config) {
                                 await refresh(id, abort.signal);
                             if (degraded)
                                 break;
-                            // 台账收口(run 终态 / 显式 stop / 错误连击 / 被别的连线身份顶掉)⇒ 退回外层的
-                            // 「退避 + 重取权威快照」;下一轮的 ensure 决定要不要重开(只有 error 收口会重开)。
                             if (beat === 'closed')
                                 break;
                         }
@@ -1227,8 +889,6 @@ export function createLiveWorkflowSource(config) {
                     finally {
                         ledger.consumers -= 1;
                     }
-                    // 🔴 本源的台账被**另一个连线身份**顶掉过 ⇒ 本源就此不再 ensure(否则两个 scope 的
-                    //    消费者会把同一个槽位来回换)。如实降级:详情页此后只走 GET 轮询。
                     if (ledger.displaced) {
                         activityDisabled = true;
                         if (engineWireDebugEnabled()) {
@@ -1236,7 +896,6 @@ export function createLiveWorkflowSource(config) {
                         }
                     }
                 }
-                // ledger 收口/降级 → 小回退后在下一轮重取权威快照(GET 此后是权威)。
                 if (!disposed && !abort.signal.aborted)
                     await abortableSleep(STREAM_DROP_BACKOFF_MS, abort.signal);
             }
@@ -1248,20 +907,12 @@ export function createLiveWorkflowSource(config) {
             }
         }
     }
-    // REF-CC-147(域词表-17):此前这里有一个私有 `sleep()`,裸 Promise+定时器形
-    // ——不感知 abort:dispose() 唤不醒正在等待的那一轮,循环最多多跑一轮,且未清的 setTimeout 在
-    // Node 上继续维持事件循环存活(拖慢 headless `-p` 车道的进程退出)。已改用共享叶 abortableSleep
-    // (与 agentSession/backgroundView.ts 同一实现,详见 ./abortableSleep.ts 头注),消费点全改传
-    // `abort.signal` ——dispose() 一旦 `abort.abort()`,四处退避里在飞的那一个立即唤醒。
-    // 差分① 的 fail-soft 半场:工厂造不出 client(SDK 拒绝构造)⇒ 不起循环、恒 degraded,
-    // `snapshot()` 恒 null ⇒ 宿主走它既有的 mock/空态回落。**绝不抛进宿主**(与 501/404/空列表同路)。
     if (client === null) {
         degraded = true;
         phase = 'unavailable';
         lastError = 'client construction failed (invalid baseUrl/credentials)';
     }
     else {
-        // kick off the background consumer (fire-and-forget; all failures captured into status()).
         void consume();
     }
     return {
@@ -1273,14 +924,11 @@ export function createLiveWorkflowSource(config) {
         },
         subscribe(onChange) {
             listeners.add(onChange);
-            // 订阅即对账:订阅前就已经解析完的话,notify() 那一发已经打空了(当时还没有订阅者)——
-            // 不在这里补一发,宿主就要白等一整个轮询 tick(配对机制必须共享前提)。
             if (current !== null && !disposed) {
                 try {
                     onChange();
                 }
                 catch {
-                    /* 订阅者自己的问题,不许弄坏本源 */
                 }
             }
             return () => {