@dipoleml/dcode-cli 1.0.0 → 1.2.0

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-runs-holes.js

@@ -0,0 +1,202 @@
+// ============================================================
+// workflowRuns 归约的留白分支：`hole-reached` / `hole-filled`，以及阶段表上的留白下标
+// ============================================================
+// 从 workflow-runs-reducer.ts 拆出（max-lines 门，与 phases / started 同一先例）。
+// 契约见 docs/dynamic-workflow/presentation.md「Holes on the timeline」的「The model」一段与
+// apps/dcode-cli/packages/dynamic-workflow/docs/execution-engine.md「Holes」。
+import { WORKFLOW_RUNS_LIMITS, } from "./workflow-runs.js";
+import { boundedPhaseName, nonEmptyString } from "./workflow-runs-entries.js";
+/**
+ * 留白的站点 id：`hole#` 加 8 位十六进制，键是留白的**名字**，与嵌套深度无关（CLI 的
+ * analysis/hole-id.ts 铸造；apps/dcode-cli/packages/dynamic-workflow/docs/analysis.md「Sites」）。
+ * id 里不再写嵌套关系：一个留白在哪个留白里面，看它自己的阶段 / 站上的 `fill`。
+ */
+export const WORKFLOW_HOLE_SITE_ID_PATTERN = /^hole#[0-9a-f]{8}$/u;
+function readEpoch(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? Math.floor(value)
+        : undefined;
+}
+/**
+ * `run-launched.holes` / `hole-filled.holes` 的搬运：下标指向**被接受的**那张 `phaseNames`，所以
+ * 越界、非整数、重复一律丢——越界的下标会让侧栏把一盏虚线灯画到一个不存在的站上。一项都不剩时
+ * 返回 `undefined`：键不建。
+ */
+export function readPhaseHoles(raw, count) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const out = [];
+    for (const value of raw) {
+        if (typeof value !== "number" || !Number.isInteger(value))
+            continue;
+        if (value < 0 || value >= count || out.includes(value))
+            continue;
+        out.push(value);
+        if (out.length >= WORKFLOW_RUNS_LIMITS.maxPhases)
+            break;
+    }
+    return out.length === 0 ? undefined : out;
+}
+/**
+ * 载荷上的声明阶段表（`run-launched` 与 `hole-filled` 同形）：按声明序、裁到与 `phases` 同一对界。
+ * 空表返回 `undefined`，调用方据此不动已有的表。
+ */
+export function readPhaseNames(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const names = [];
+    for (const value of raw) {
+        if (typeof value !== "string")
+            continue;
+        const name = value.slice(0, WORKFLOW_RUNS_LIMITS.maxPhaseNameLength);
+        if (name.length === 0)
+            continue;
+        names.push(name);
+        if (names.length >= WORKFLOW_RUNS_LIMITS.maxPhases)
+            break;
+    }
+    return names.length === 0 ? undefined : names;
+}
+/**
+ * `hole-reached`：run 走到一个开着的留白，那条分支停驻。按**站点 id** upsert——循环里同一站点会停驻
+ * 第二个 ordinal，表里只留最新的；重放同一条事件逐字节无变化（顶层的结构比对随即返回 null）。
+ * `name` 是这条记录存在的全部理由（每个面都按名字标它），缺席只抬水位。触界与 nodes / actors 同族：
+ * 拒绝新条目、已有条目照常更新、置 truncated。
+ */
+/** 提示语截到上限：超长时留 499 字加 `…`，总长仍是 500。 */
+function boundedHolePrompt(raw) {
+    if (raw === undefined)
+        return undefined;
+    const max = WORKFLOW_RUNS_LIMITS.maxHolePromptLength;
+    return raw.length <= max ? raw : `${raw.slice(0, max - 1)}…`;
+}
+export function reduceHoleReached(run, payload) {
+    const instance = payload.instance;
+    if (typeof instance !== "object" || instance === null)
+        return run;
+    const siteId = nonEmptyString(instance.siteId);
+    const ordinalRaw = instance.ordinal;
+    const ordinal = typeof ordinalRaw === "number" && Number.isInteger(ordinalRaw) ? ordinalRaw : 0;
+    const name = boundedPhaseName(nonEmptyString(payload.name));
+    if (siteId === undefined || name === undefined)
+        return run;
+    const type = nonEmptyString(payload.type)?.slice(0, WORKFLOW_RUNS_LIMITS.maxHoleTypeLength);
+    const prompt = boundedHolePrompt(nonEmptyString(payload.prompt));
+    // 到达时刻只能由事件携带（本模块无时钟）；两个键名都认：`reachedAt` 是通知载荷的词，`since` 是投影的词。
+    const since = readEpoch(payload.reachedAt) ?? readEpoch(payload.since);
+    const entry = {
+        siteId,
+        ordinal,
+        name,
+        ...(type === undefined ? {} : { type }),
+        ...(prompt === undefined ? {} : { prompt }),
+        state: "waiting",
+        ...(since === undefined ? {} : { since }),
+    };
+    const existing = run.holes ?? [];
+    const index = existing.findIndex((hole) => hole.siteId === siteId);
+    if (index >= 0) {
+        // 已有记录（含补全过又被重新到达的——那是 resume 重放到一个还没补的站点）：换成 waiting，
+        // 类型缺席时沿用记过的那个。
+        const previous = existing[index];
+        const merged = {
+            ...entry,
+            ...(entry.type === undefined && previous.type !== undefined ? { type: previous.type } : {}),
+            ...(entry.prompt === undefined && previous.prompt !== undefined
+                ? { prompt: previous.prompt }
+                : {}),
+        };
+        return { ...run, holes: existing.map((hole, i) => (i === index ? merged : hole)) };
+    }
+    if (existing.length >= WORKFLOW_RUNS_LIMITS.maxHoles)
+        return { ...run, truncated: true };
+    return { ...run, holes: [...existing, entry] };
+}
+/**
+ * `hole-filled`：主代理的补全接进了 run。三件事一步做完——那条记录翻成 filled、阶段表换成补全后的
+ * 声明表（超集：留白的体在留白的位置展开）、留白下标表整张换新。「同时在跑」表按插入位置右移：
+ * 补全只在留白那一站之后插入 k 站，旧表里 > h 的下标一律 +k；表的形状对不上（不是这种插入）就丢掉，
+ * 宁可侧栏少画双线段，也不把它连到错的站上。
+ */
+export function reduceHoleFilled(run, payload) {
+    const siteId = nonEmptyString(payload.siteId);
+    if (siteId === undefined)
+        return run;
+    const filledAt = readEpoch(payload.filledAt);
+    const filledBy = nonEmptyString(payload.filledBy)?.slice(0, 128);
+    let next = run;
+    const existing = run.holes ?? [];
+    const index = existing.findIndex((hole) => hole.siteId === siteId);
+    if (index >= 0) {
+        // 提示语只为等待体而存在：补全后丢掉，已结算的 run 状态不背着它。
+        const { prompt: _prompt, ...reached } = existing[index];
+        void _prompt;
+        const filled = {
+            ...reached,
+            state: "filled",
+            ...(filledAt === undefined ? {} : { filledAt }),
+            ...(filledBy === undefined ? {} : { filledBy }),
+        };
+        next = { ...next, holes: existing.map((hole, i) => (i === index ? filled : hole)) };
+    }
+    const phaseNames = readPhaseNames(payload.phaseNames);
+    if (phaseNames === undefined)
+        return next;
+    const phaseHoles = readPhaseHoles(payload.holes, phaseNames.length);
+    const phaseAlongside = shiftPhaseAlongside(run, phaseNames);
+    const { phaseAlongside: _stale, phaseHoles: _staleHoles, ...rest } = next;
+    void [_stale, _staleHoles];
+    return {
+        ...rest,
+        phaseNames,
+        ...(phaseAlongside === undefined ? {} : { phaseAlongside }),
+        ...(phaseHoles === undefined ? {} : { phaseHoles }),
+    };
+}
+/** 旧表 + 「留白位置之后插入 k 站」 → 新表上的「同时在跑」下标；形状对不上返回 undefined。 */
+function shiftPhaseAlongside(run, names) {
+    const old = run.phaseNames;
+    const alongside = run.phaseAlongside;
+    if (old === undefined || alongside === undefined)
+        return undefined;
+    const inserted = names.length - old.length;
+    if (inserted < 0)
+        return undefined;
+    // 找插入点 h：前缀 old[0..h] 与后缀 old[h+1..] 都逐字相同。
+    let h = -1;
+    for (let i = 0; i < old.length; i += 1) {
+        if (old[i] !== names[i])
+            break;
+        h = i;
+    }
+    if (h < 0)
+        return undefined;
+    for (let i = h + 1; i < old.length; i += 1) {
+        if (old[i] !== names[i + inserted])
+            return undefined;
+    }
+    const shift = (i) => (i <= h ? i : i + inserted);
+    const out = [];
+    for (let i = 0; i < names.length; i += 1) {
+        const source = i <= h ? i : i - inserted;
+        const entry = i > h && i <= h + inserted ? [] : (alongside[source] ?? []);
+        out.push(entry.map(shift));
+    }
+    return out.some((entry) => entry.length > 0) ? out : undefined;
+}
+/**
+ * 剥掉 waiting 记录（新的一世 / 终态）：真相是进程内的停驻 deferred，与 pendingQuestions 同一条理由——
+ * 一个已停的 run 没有人在等补全；resume 重跑到那个站点会再发一条 `hole-reached`。filled 记录跨世保留：
+ * 那是接进 run 的代码，不是残影。一条不剩时整个键摘掉。
+ */
+export function withoutWaitingHoles(run) {
+    if (run.holes === undefined)
+        return run;
+    const kept = run.holes.filter((hole) => hole.state === "filled");
+    if (kept.length === run.holes.length)
+        return run;
+    const { holes: _dropped, ...rest } = run;
+    void _dropped;
+    return kept.length === 0 ? rest : { ...rest, holes: kept };
+}
+//# sourceMappingURL=workflow-runs-holes.js.map

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-runs-legacy.d.ts

@@ -3,7 +3,7 @@ import { type WorkflowRunsState } from "./workflow-runs.js";
  * 按旧界裁剪；裁过的 run 置 `truncated: true`（读面据它显示「仅展示 N/M 步的详情」）。
  *
  * **不裁别的**：旧消费者认不出的新可选键是无害的（容器非 strict，多余的键被剥掉而已），
- * 而为了"干净"去剥它们反而要维护第二份字段表，增加字段不一致的风险。
+ * 而为了"干净"去剥它们反而要维护第二份字段表——那正是 2026-09-04 事故的形状。
  *
  * 无需裁剪时返回**同一个对象**：这个函数在每次 flush 上都会跑一遍，白白造一份新状态会让
  * 下游所有按引用 memo 的地方失效。

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-runs-legacy.js

@@ -15,7 +15,7 @@ import { WORKFLOW_RUNS_LEGACY_LIMITS, } from "./workflow-runs.js";
  * 按旧界裁剪；裁过的 run 置 `truncated: true`（读面据它显示「仅展示 N/M 步的详情」）。
  *
  * **不裁别的**：旧消费者认不出的新可选键是无害的（容器非 strict，多余的键被剥掉而已），
- * 而为了"干净"去剥它们反而要维护第二份字段表，增加字段不一致的风险。
+ * 而为了"干净"去剥它们反而要维护第二份字段表——那正是 2026-09-04 事故的形状。
  *
  * 无需裁剪时返回**同一个对象**：这个函数在每次 flush 上都会跑一遍，白白造一份新状态会让
  * 下游所有按引用 memo 的地方失效。

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-runs-phases.js

@@ -1,4 +1,5 @@
 import { WORKFLOW_RUNS_LIMITS, } from "./workflow-runs.js";
+import { readPhaseHoles } from "./workflow-runs-holes.js";
 /**
  * `phase-entered` 的归约：控制流经过了
  * 一个 `phase("…")` 标记。住在 reducer 主文件之外与并发观察同一个理由——主文件的 max-lines 门。
@@ -34,7 +35,15 @@ export function reduceRunLaunched(run, payload) {
     if (phaseNames.length === 0)
         return run;
     const phaseAlongside = readPhaseAlongside(payload.phaseAlongside, phaseNames.length);
-    return { ...run, phaseNames, ...(phaseAlongside === undefined ? {} : { phaseAlongside }) };
+    // 留白下标表（docs/dynamic-workflow/presentation.md「Holes on the timeline」）与「同时在跑」表同一姿态：
+    // 搭声明表的车，下标按被接受的那张表裁。
+    const phaseHoles = readPhaseHoles(payload.holes, phaseNames.length);
+    return {
+        ...run,
+        phaseNames,
+        ...(phaseAlongside === undefined ? {} : { phaseAlongside }),
+        ...(phaseHoles === undefined ? {} : { phaseHoles }),
+    };
 }
 /**
  * 「同时在跑」表的搬运，只在 `phaseNames` 被接受之后调用。

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-runs-reducer.d.ts

@@ -24,7 +24,7 @@ export interface WorkflowRunProgressEnvelope {
  * 内容逐字节相同。调用方据此决定不发 `state.updated` / 不刷 UI——revision 因此只在真有
  * 变化时抬升（幂等重放不抬 revision）。
  *
- * `previous` 缺席等价于空态 `{ revision: 0, runs: [] }`。`limits` 默认使用
+ * `previous` 缺席等价于空态 `{ revision: 0, runs: [] }`。`limits` 只为测试留的注入口，默认就是
  * {@link WORKFLOW_RUNS_LIMITS}（生产上没有第二套界）。
  */
 export declare function reduceWorkflowRunsState(previous: WorkflowRunsState | undefined, envelope: WorkflowRunProgressEnvelope, limits?: WorkflowRunEntryLimits): WorkflowRunsState | null;

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-runs-reducer.js

@@ -18,22 +18,25 @@
 //      `executing` / `waiting` 是 driver 的观察：
 //      模型请求真的发出去了 / 在等进程级槽位或退避；两者在 dispatched 之后来回切换。
 //   2. resume 的完结命中短路**直接发 node-settled**，不经 node-queued（ask 在 scheduler.ts 的
-//      releaseCachedAsk / tryImportedSettle，world-read 在 engine-world.ts 的重放与导入命中），
-//      而 `kind` 只在 queued 上携带——所以 node.kind 是可缺省的，不是漏填。
-//   3. run 级用量：`usage-updated` 直接携带已花 token 总量；
+//      releaseCachedAsk / tryImportedSettle，world-read 在 engine-world.ts 的重放与导入命中）。
+//      ask 的那一条重发出生事实（kind / actor / actorSeq / instructionsHead），world-read 的不带，
+//      更早的 journal 里的也不带——所以 node.kind 与 actor ref 是可缺省的，不是漏填。
+//   3. run 级用量（docs/dynamic-workflow/authoring.md）：`usage-updated` 直接携带已花 token 总量；
 //      `nodesUsed` 由 `node-dispatched` 的首次相位跃迁计数（同一实例重放不重复计数），
 //      没有任何上限可供反算，也不需要。
 import { WORKFLOW_RUNS_LIMITS, } from "./workflow-runs.js";
 import { serializeWorkflowArtifact } from "./workflow-artifact.js";
+import { actorsWithTranscriptSession } from "./workflow-runs-actor-session.js";
 import { withDerivedWorkflowActorStatuses } from "./workflow-runs-actor-status.js";
 import { countTaggedReport, upsertBoundedByArtifactId, workflowArtifactSummary, } from "./workflow-runs-artifacts.js";
 import { countUnlistedInstance, discountUnlistedInstance, evictForEntryBudget, } from "./workflow-runs-caps.js";
 import { absorbRefusedActor, absorbRefusedSettledNode, admitsNewEntry, seatWorkflowNode, withRoomForActor, } from "./workflow-runs-eviction.js";
 import { reduceConcurrencyChanged, reduceRunCapsChanged, withoutCooldown, } from "./workflow-runs-concurrency.js";
-import { boundedActorName, boundedPhaseName, nonEmptyString, workflowActorEntry, } from "./workflow-runs-entries.js";
+import { boundedActorName, boundedPhaseName, nonEmptyString, workflowActorEntry, workflowInstanceRef, } from "./workflow-runs-entries.js";
 import { canonicalWorkflowRun, workflowRunUnchanged } from "./workflow-runs-delta.js";
 import { readRunIdField, readWorkflowRunStopReason } from "./workflow-runs-lineage.js";
 import { carryNodeProgress, reduceNodeProgress } from "./workflow-runs-node-progress.js";
+import { reduceHoleFilled, reduceHoleReached, withoutWaitingHoles } from "./workflow-runs-holes.js";
 import { reducePhaseEntered, reduceRunLaunched } from "./workflow-runs-phases.js";
 import { reduceRunStarted } from "./workflow-runs-started.js";
 import { upsertBoundedByInstance, upsertBoundedByQid } from "./workflow-runs-tables.js";
@@ -57,7 +60,7 @@ const NODE_EVENT_PHASE = {
  * 内容逐字节相同。调用方据此决定不发 `state.updated` / 不刷 UI——revision 因此只在真有
  * 变化时抬升（幂等重放不抬 revision）。
  *
- * `previous` 缺席等价于空态 `{ revision: 0, runs: [] }`。`limits` 默认使用
+ * `previous` 缺席等价于空态 `{ revision: 0, runs: [] }`。`limits` 只为测试留的注入口，默认就是
  * {@link WORKFLOW_RUNS_LIMITS}（生产上没有第二套界）。
  */
 export function reduceWorkflowRunsState(previous, envelope, limits = WORKFLOW_RUNS_LIMITS) {
@@ -124,10 +127,11 @@ function applyWorkflowRunEvent(base, eventType, payload, derived) {
             const ref = workflowInstanceRef(payload.actor);
             if (!ref)
                 return run;
-            // 出生阶段：`actor-created` 是 actor 的出生事件，戳只在这里到，
+            // 出生阶段（追记 2026-09-09）：`actor-created` 是 actor 的出生事件，戳只在这里到，
             // 没有后续事件可以携带或改写它。
             const phaseName = boundedPhaseName(nonEmptyString(payload.phaseName));
-            const actor = workflowActorEntry(ref, payload.name, phaseName, derived.actorSessionId);
+            const { actorSessionId } = derived;
+            const actor = workflowActorEntry(ref, payload.name, phaseName, actorSessionId, payload.model);
             // 表满时给这个活的新人腾位（workflow-runs-eviction.ts）；腾不出位就照旧拒新。
             // 重放的事件既不腾位也不入座（后者只在**溢出过的** run 上收紧，见 admitsNewEntry）。
             const seated = derived.advancesWaterMark ? withRoomForActor(run, ref, derived.limits) : run;
@@ -161,11 +165,12 @@ function applyWorkflowRunEvent(base, eventType, payload, derived) {
             // ——它早已计进 nodesUnlisted，再列一次就是既列又计。
             const born = eventType === "node-queued" || (eventType === "node-settled" && payload.cached === true);
             const actorRef = workflowInstanceRef(payload.actor);
-            // 带出生事实的 `node-dispatched`：引擎在派发那一刻重发这条实例的 `node-queued` 与它子代理的 `actor-created`
+            // 带出生事实的 `node-dispatched`（docs/dynamic-workflow/presentation.md「Reduction」的
+            // activation）：引擎在派发那一刻重发这条实例的 `node-queued` 与它子代理的 `actor-created`
             // 携带过的同一份事实，于是表外的实例可以在**被派活的那一刻**连人带活回到表上。
             // 缺 actor ref 即老 journal 或 world-read 的裸派发，照旧处理。
             const dispatchActor = eventType === "node-dispatched" && actorRef !== null
-                ? workflowActorEntry(actorRef, payload.actorName, boundedPhaseName(nonEmptyString(payload.actorPhaseName)), derived.actorSessionId)
+                ? workflowActorEntry(actorRef, payload.actorName, boundedPhaseName(nonEmptyString(payload.actorPhaseName)), derived.actorSessionId, payload.actorModel)
                 : null;
             // 腾位、B2 的拒绝与 activation 三件事的唯一入口（workflow-runs-eviction.ts）。
             const seating = seatWorkflowNode(run, {
@@ -211,7 +216,7 @@ function applyWorkflowRunEvent(base, eventType, payload, derived) {
             // dispatched 之后的相位，不再计数——归约必须幂等（顶层靠结构比对判「无变化」）。
             // 触界被拒的实例查不到 previousNode，会照常计数：步数是 run 级事实，不受展示界约束。
             // 也正因为它查不到 previousNode，相位这道去重对它无效——重放那条 dispatched 会把步数
-            // 越推越高。所以在**溢出过的** run 上这条计数与 nodesUnlisted 同规，
+            // 越推越高（property 测试逮到的）。所以在**溢出过的** run 上这条计数与 nodesUnlisted 同规，
             // 只认抬过水位的事件；界之下每条实例都有自己那行，相位去重够用，一个字节都不必变。
             const firstDispatch = eventType === "node-dispatched" &&
                 admitsNewEntry(run, derived.advancesWaterMark) &&
@@ -233,6 +238,8 @@ function applyWorkflowRunEvent(base, eventType, payload, derived) {
                 : seated;
             return withDerivedWorkflowActorStatuses({
                 ...absorbed,
+                // 转录在哪条会话里（workflow-runs-actor-session.ts）：缓存命中的结算与派发各说一次。
+                actors: actorsWithTranscriptSession(absorbed.actors, eventType, payload, actorRef, derived.actorSessionId),
                 ...(usage === seated.usage ? {} : { usage }),
                 nodes: upsertedNodes.list,
                 ...(upsertedNodes.truncated || seated.truncated ? { truncated: true } : {}),
@@ -399,7 +406,8 @@ function applyWorkflowRunEvent(base, eventType, payload, derived) {
         case "concurrency-changed":
             return reduceConcurrencyChanged(run, payload);
         /**
-         * run-caps-changed：run **在飞时**它自己的那条并发界被改了（只改 `max_concurrency` 的修订就地生效，不停这次 run、不另起一次）。载荷与
+         * run-caps-changed：run **在飞时**它自己的那条并发界被改了（只改 `max_concurrency` 的修订
+         * 就地生效，不停这次 run、不另起一次；docs/dynamic-workflow/concurrency.md）。载荷与
          * `run-started` 同形，规则也是同一条，所以与它同住 workflow-runs-concurrency.ts。
          * 同样不碰 `nodes[]` 与 actor 状态：界是闸门，不是任何节点的事。
          */
@@ -410,6 +418,14 @@ function applyWorkflowRunEvent(base, eventType, payload, derived) {
             return reducePhaseEntered(run, payload);
         case "run-launched":
             return reduceRunLaunched(run, payload);
+        /**
+         * hole-reached / hole-filled：留白的停驻与补全（docs/dynamic-workflow/presentation.md「Holes on the
+         * timeline」）。不碰 nodes / actors——留白没有节点行；规则在同族的 workflow-runs-holes.ts。
+         */
+        case "hole-reached":
+            return reduceHoleReached(run, payload);
+        case "hole-filled":
+            return reduceHoleFilled(run, payload);
         case "run-settled": {
             const status = payload.status;
             const error = isPlainRecord(payload.error) ? payload.error : undefined;
@@ -421,7 +437,8 @@ function applyWorkflowRunEvent(base, eventType, payload, derived) {
             // 若还挂着 pending，那也只是一条永远不会有下文的残影。
             // 冷却是"新派发被冻结到何时"，终态 run 不再派发任何东西——留着它只会让状态头显示一个
             // 没有对象的倒计时。cap / ceiling 照留：它们是这次 run 跑在什么并发下的历史事实。
-            const cleared = withoutCooldown(withoutPendingQuestions(run, () => false));
+            // 停驻中的留白与停驻问题同命：真相是进程内的 deferred，终态 run 没有人在等补全；补上了的照留。
+            const cleared = withoutWaitingHoles(withoutCooldown(withoutPendingQuestions(run, () => false)));
             // actor 三态里 waiting / completed 的分界看 run 是否终态，所以终态要重新派生一遍：
             // 一个建了却没被 ask 过的 actor 在 run 结束那一刻从「等待」变成「已完成」。
             // 三终态词；`stopReason` 只在 stopped 时搬运，
@@ -454,16 +471,6 @@ function applyWorkflowRunEvent(base, eventType, payload, derived) {
             return run;
     }
 }
-/** 引擎的 `InstanceRef` / `ActorRef` 同构：站点 id × 序号。缺任一即无法定位，返回 null。 */
-function workflowInstanceRef(value) {
-    if (!isPlainRecord(value))
-        return null;
-    const siteId = nonEmptyString(value.siteId);
-    const ordinal = value.ordinal;
-    if (siteId === undefined || typeof ordinal !== "number")
-        return null;
-    return { siteId, ordinal };
-}
 /**
  * 按谓词保留停驻问题，并在**一条不剩时把整个键摘掉**（而不是留一个空数组）。
  *

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-runs-started.js

@@ -4,9 +4,10 @@
 // 从 workflow-runs-reducer.ts 拆出（max-lines 门）：主归约只剩 switch 的分派，与
 // `concurrency-changed` / `phase-entered` 同一条先例。这条事件要说的事最多——resume 的
 // 重臂语义、lineage 指针、本 run 自己的并发界——而三者彼此相关：同一个 runId 的第二条
-// `run-started` 既要清掉上一世的结算残影，又不能把进程里已经学到的共享 cap 抹回天花板。
+// `run-started` 既要清掉上一世的结算残影，又不能把进程里已经学到的共享 cap 抹回默认并发。
 import { reduceRunStartedConcurrency } from "./workflow-runs-concurrency.js";
 import { workflowRunTablesForNewLife } from "./workflow-runs-eviction.js";
+import { withoutWaitingHoles } from "./workflow-runs-holes.js";
 import { readRunIdField } from "./workflow-runs-lineage.js";
 import { WORKFLOW_RUNS_LIMITS } from "./workflow-runs.js";
 /**
@@ -60,8 +61,10 @@ export function reduceRunStarted(run, payload) {
     // 这条事件到达。读不出就退回已知值——老 CLI 不发这个键，而把已经显示出来的模型抹掉是退化里
     // 最坏的一种：run 看上去换了模型，其实只是少了一个字段。缺席即整个键不在（不是 undefined）。
     const subagentModel = readSubagentModel(payload.subagentModel) ?? rebased.subagentModel;
+    // 停驻中的留白与停驻问题同属上一世的残影（workflow-runs-holes.ts）：resume 重跑到那个站点会再发
+    // 一条 `hole-reached`；补上了的留白是接进 run 的代码，跨世保留。
     return reduceRunStartedConcurrency({
-        ...rebased,
+        ...withoutWaitingHoles(rebased),
         ...(resumedFrom === undefined ? {} : { resumedFrom }),
         ...(subagentModel === undefined ? {} : { subagentModel }),
         status: "running",

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-runs-tables.js

@@ -1,7 +1,8 @@
 // ============================================================
 // workflowRuns 里几张**有界表**的 upsert 语义
 // ============================================================
-// 纯函数，负责表项更新与容量判断，不读取时钟或执行 I/O。
+// 从 workflow-runs-reducer.ts 拆出（max-lines 门），与 -started.ts / -phases.ts / -eviction.ts
+// 同一条先例，也同一条纪律：纯函数、无时钟、无 I/O。
 //
 // 这两个函数说的是同一句话的两半：一张表怎么认「这是同一条记录」，以及装不下时怎么办。
 // 触界的语义是**拒新、仍更新已有**——把一个正在跑的实例的相位冻结在 "queued" 上，比少列一个

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-runs-unlisted.js

@@ -1,9 +1,10 @@
 // ============================================================
 // 表外条目的归属账：`unlistedByPhase` 的每一格怎么加、怎么减、什么时候整格消失
 // ============================================================
-// 本模块是纯函数，不读取时钟或执行 I/O。淘汰规则决定谁离开表，这里维护离开后的分阶段计数。
+// 从 workflow-runs-eviction.ts 拆出（主文件的 max-lines 门），也同一条纪律：纯函数、无时钟、
+// 无 I/O。淘汰说的是「谁离开表」，这里说的是「离开之后它还怎么被数出来」。
 //
-// 读面是按**站**画的：一个站点
+// 读面是按**站**画的（docs/dynamic-workflow/presentation.md「Past six participants」）：一个站点
 // 的花名册、计数环和「N more」都得把自己那一格的表外条目加回去。run 级的两个计数器
 // （workflow-runs-caps.ts）说得出一条 run 总共少列了多少，说不出少在哪一站——这张格子表就是
 // 那个缺口。
@@ -18,7 +19,9 @@
 //
 // 每次改动之后整格夹到 `actorsFailed ≤ actorsSettled ≤ actors`，这是这一格的**法律**而不是
 // 一道补丁：它正是让 `actorsSettled` 既能涨也能落的那条规则。它必须能落——一个子代理在它两次
-// ask 之间看上去就是「已完成」，淘汰于是给它盖了个已结束的戳，而它的下一次派发又把它接回表上。这一格不记录**是谁**回来了，所以在 activation 那一刻去减
+// ask 之间看上去就是「已完成」，淘汰于是给它盖了个已结束的戳，而它的下一次派发又把它接回表上
+// （曾经这里写着 actorsSettled「只增不减，因为已经结束的子代理不会再被派活回表」，那句话对
+// 多次 ask 的子代理是错的）。可是这一格记不住**是谁**回来了，所以在 activation 那一刻去减
 // `actorsSettled` 只能靠猜，而在宽 fan-out 里会猜得离谱：那个阶段有几百个子代理是**出生时**
 // 就被拒的、根本没结算过，每一次回表都会去扣一笔不属于它的账。夹取只在一格拥挤时错，而且是
 // 暂时的——回表的那个已完成子代理把自己的已结束标记留给同阶段另一个未列出的子代理，直到这一格