@dipoleml/dcode-cli 1.0.0 → 1.2.0

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/transport.js

@@ -464,13 +464,22 @@ export const v4ConversationFileChangesResultSchema = z
 // （`appendEvent` 单调分配），在 workflowRuns[].lastEventSequence 抬升时重取。
 // 刻意**不是** v4 command：command 的 ACK 结果是 commandResultSchema 那个封闭的「变更结果」
 // 判别联合，把一页只读事件塞进去等于把读放进写的词汇表，还要白背 baseRevision/幂等那套机制。
+/**
+ * 事件日志一页的两道界，网关按它们取数（apps/dcode-cli/packages/dynamic-workflow/docs/execution-engine.md
+ * 「Reading the journal」）。字节按存储里的序列化字节计、取协议单帧上限的四分之一：条数单独
+ * 管不住字节，500 条带着大 report item 的事件足以顶到单帧上限。
+ */
+export const WORKFLOW_RUN_EVENTS_PAGE_LIMITS = {
+    maxEvents: 500,
+    maxBytes: PROTOCOL_V4_LIMITS.logicalFrameAssemblyMaxBytes / 4,
+};
 export const v4ConversationWorkflowRunEventsParamsSchema = z
     .object({
     sessionId: z.string().min(1),
     runId: z.string().min(1),
     /** 只取 sequence 严格大于该值的事件；缺省从头取。 */
     afterSequence: z.number().int().nonnegative().optional(),
-    limit: z.number().int().positive().max(500).optional(),
+    limit: z.number().int().positive().max(WORKFLOW_RUN_EVENTS_PAGE_LIMITS.maxEvents).optional(),
 })
     .strict();
 export const v4ConversationWorkflowRunEventsResultSchema = z
@@ -485,7 +494,7 @@ export const v4ConversationWorkflowRunEventsResultSchema = z
         truncated: z.boolean().optional(),
     })
         .strict()),
-    /** 本页取满 limit 且后面仍有事件。 */
+    /** 本页之后仍有事件（页可能因条数或字节上界提前收尾）。 */
     hasMore: z.boolean(),
 })
     .strict();
@@ -811,20 +820,24 @@ export const v4AttachmentReadResultSchema = z
         .string()
         .refine((value) => value.startsWith("image/") ||
         value.startsWith("video/") ||
-        value.split(";", 1)[0]?.trim().toLowerCase() === "application/pdf", "attachment preview only supports image/video/pdf media types"),
+        value.split(";", 1)[0]?.trim().toLowerCase() === "application/pdf" ||
+        value.split(";", 1)[0]?.trim().toLowerCase() === "text/plain", "attachment preview only supports image/video/pdf/plain text types"),
     totalBytes: z.number().int().nonnegative().max(PROTOCOL_V4_LIMITS.attachmentPreviewMaxBytes),
     nextOffset: z.number().int().positive().nullable(),
 })
     .strict()
     .superRefine((value, context) => {
-    if (value.mediaType.startsWith("image/") &&
+    if (
+    // 根因：运行时已支持材料文本，响应 schema 仍只接受媒体，导致跨进程预览失败。
+    (value.mediaType.startsWith("image/") ||
+        value.mediaType.split(";", 1)[0]?.trim().toLowerCase() === "text/plain") &&
         value.totalBytes > PROTOCOL_V4_LIMITS.attachmentMaxBytes) {
         context.addIssue({
             code: "too_big",
             maximum: PROTOCOL_V4_LIMITS.attachmentMaxBytes,
             origin: "number",
             inclusive: true,
-            message: "image preview exceeds total byte limit",
+            message: "image/text preview exceeds total byte limit",
             path: ["totalBytes"],
         });
     }

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/wire-assembler.js

@@ -101,7 +101,8 @@ export class TopicWireFrameAssembler {
     accept(wire, now = Date.now()) {
         const events = this.expire(now);
         const key = routeKey(wire.topic, wire.subscriptionId);
-        if (!Number.isSafeInteger(wire.logicalFrameOrdinal) || wire.logicalFrameOrdinal < 1) {
+        if (!Number.isSafeInteger(wire.logicalFrameOrdinal) ||
+            wire.logicalFrameOrdinal < 1) {
             events.push(this.fault(wire, "proto.frameAssemblyMetadataMismatch"));
             return events;
         }

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/wire-fault.js

@@ -1,11 +1,14 @@
 // V4 physical assembly fault 的分类：**内容确定性失败** vs 瞬态失败。
+// spec：docs/v4-refactor/04-sync-and-recovery.md 封闭规则 11、
+// docs/v4-refactor/05-transport-and-backpressure.md「客户端规则」。
 //
 // 恢复阶梯默认把 fault 当瞬态处理：先 same-sub resync（服务端可能回 resume），再断档则升级
 // forceSnapshot，仍不成则 fail closed。这套升级对丢片、超时、校验和不符是对的——重投一次很可能
 // 就好了。对 **schema 拒收** 却是错的：字节已经过了 length/checksum/UTF-8/JSON 四道关，被拒说明
 // 本端读不懂对端发来的**内容**，而 resume 档只会把同一批 delta 再投一遍，必然同样被拒。
 //
-// 工具卡载荷出现不兼容字段时，重投相同内容无法恢复；应尝试快照后明确报告内容不兼容。
+// 2026-09-21（sess_4142de31）的事故就是这条：一个工具卡载荷多带两个键，恢复阶梯在同一份内容上
+// 烧掉三帧后 fail closed，用户手动「重新连接」两次、每次再烧三帧，会话再也打不开。
 //
 // 本模块只回答「这个 reason code 是不是确定性内容失败」，不决定怎么处置——处置在两个 store 里
 // （conversationProjectionStore / sessionsIndexStore）。

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/wire-reassembly.js

@@ -11,7 +11,8 @@ function frameMatchesEnvelope(frame, wire) {
     if (typeof frame !== "object" || frame === null)
         return false;
     const record = frame;
-    return record.topic === wire.topic && record.subscriptionId === wire.subscriptionId;
+    return (record.topic === wire.topic &&
+        record.subscriptionId === wire.subscriptionId);
 }
 export function reassembleTopicWireFrames(wires, frameSchema, options = {}) {
     if (wires.length === 0) {
@@ -43,8 +44,9 @@ export function reassembleTopicWireFrames(wires, frameSchema, options = {}) {
             ? { kind: "complete", frame: parsed.data, deliveryKind: first.deliveryKind }
             : { kind: "rejected", reasonCode: WIRE_FAULT_INVALID_PAYLOAD };
     }
-    if (first.fragmentCount > PROTOCOL_V4_LIMITS.logicalFrameAssemblyMaxFragments) {
-        // fragmentCount 曾只受 logicalBytes 约束，恶意元数据可在
+    if (first.fragmentCount >
+        PROTOCOL_V4_LIMITS.logicalFrameAssemblyMaxFragments) {
+        // 修复原因：fragmentCount 曾只受 logicalBytes 约束，恶意元数据可在
         // 缺片路径制造千万级 missingIndexes，先用协议硬上限阻断无界分配。
         return {
             kind: "rejected",

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

@@ -28,7 +28,33 @@ export declare const WORKFLOW_ARTIFACT_LIMITS: {
     readonly maxItemsPerPage: 500;
     /** 一页的缺省条数（调用方不传 limit 时网关用它）。 */
     readonly defaultItemsPerPage: 200;
+    /**
+     * `workflowRunArtifactData` 一页的字节上界（按存储里的序列化字节计），由网关传给存储层。
+     * 取协议单帧上限（16 MiB）的四分之一：条数上界单独管不住字节——500 条 × 32 KiB 就顶到了
+     * 单帧上限，于是一页可能根本发不出去。一页至少带一条，所以单条的上限（`REPORT_CAPS`）
+     * 必须远小于单帧上限。
+     */
+    readonly maxPageBytes: number;
+    /** `workflowRunArtifactData` 一次最多点名几个字段路径（一张看板的 spec 用不到这么多）。 */
+    readonly maxFieldsPerRequest: 32;
+    /** 一个字段路径的最大长度。 */
+    readonly maxFieldPathLength: 256;
+    /**
+     * 一个字段值的序列化字节上界。超过的值回成一段截短的字符串（前 1,000 个字符加「…」）：
+     * 图表只用数值，表格与看板的格子本来就只显示短文本。
+     */
+    readonly maxFieldValueBytes: 4096;
 };
+/**
+ * 按点路径从一条 report item 里取值："timing.after"、"rounds.0.ms"（docs/execution-engine.md
+ * 「Reading the journal」）。
+ *
+ * 这是**协议上的契约**，不只是渲染器的工具函数：看板取数时 CLI 在 SQLite 里按同一套规则把
+ * 字段取出来（adapters 的 dwf-journal-fields.ts），渲染器拿到的值必须与它自己从整条 item 里
+ * 取出来的逐字相同。规则：按 `.` 切段；当前值是数组时，段按 `Number(段)` 当下标（非负整数且
+ * 在界内才算）；是对象时按键取；走不通（null、标量、越界、缺键）得 `undefined`。
+ */
+export declare function readWorkflowArtifactField(item: unknown, path: string): unknown;
 /**
  * 一个产物版本的**元数据**（journal `dwf_node.result_json` 上 `ArtifactVersionRecord` 的
  * zod 镜像）。字节不在这里——`uri` 指向 tool-artifact store，取字节走
@@ -100,7 +126,7 @@ export type WorkflowRunArtifact = z.infer<typeof workflowRunArtifactSchema>;
  * `workflowRunArtifactRead` 取字节）按需拉——权威始终在 journal。
  *
  * `itemCount` 在这里的职责是**刷新信号**：看板 hook 见它变化就带 `afterSequence` 增量取数。
- * 把标签 report 的原值放进快照会让 256 条 × 32KB 的最坏情形把状态帧撑到 2MB。
+ * 把标签 report 的原值放进这个高频状态键，一个 run 的条目有多少字节，每一帧就要搬多少字节。
  */
 export declare const workflowRunArtifactSummarySchema: z.ZodObject<{
     id: z.ZodString;
@@ -165,6 +191,7 @@ export declare const v4ConversationWorkflowRunArtifactDataParamsSchema: z.ZodObj
     artifactId: z.ZodString;
     afterSequence: z.ZodOptional<z.ZodNumber>;
     limit: z.ZodOptional<z.ZodNumber>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export type V4ConversationWorkflowRunArtifactDataParams = z.infer<typeof v4ConversationWorkflowRunArtifactDataParamsSchema>;
 export declare const v4ConversationWorkflowRunArtifactDataResultSchema: z.ZodObject<{
@@ -173,6 +200,7 @@ export declare const v4ConversationWorkflowRunArtifactDataResultSchema: z.ZodObj
         siteId: z.ZodString;
         ordinal: z.ZodNumber;
         item: z.ZodUnknown;
+        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>;
     hasMore: z.ZodBoolean;
 }, z.core.$strict>;

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

@@ -44,7 +44,50 @@ export const WORKFLOW_ARTIFACT_LIMITS = {
     maxItemsPerPage: 500,
     /** 一页的缺省条数（调用方不传 limit 时网关用它）。 */
     defaultItemsPerPage: 200,
+    /**
+     * `workflowRunArtifactData` 一页的字节上界（按存储里的序列化字节计），由网关传给存储层。
+     * 取协议单帧上限（16 MiB）的四分之一：条数上界单独管不住字节——500 条 × 32 KiB 就顶到了
+     * 单帧上限，于是一页可能根本发不出去。一页至少带一条，所以单条的上限（`REPORT_CAPS`）
+     * 必须远小于单帧上限。
+     */
+    maxPageBytes: PROTOCOL_V4_LIMITS.logicalFrameAssemblyMaxBytes / 4,
+    /** `workflowRunArtifactData` 一次最多点名几个字段路径（一张看板的 spec 用不到这么多）。 */
+    maxFieldsPerRequest: 32,
+    /** 一个字段路径的最大长度。 */
+    maxFieldPathLength: 256,
+    /**
+     * 一个字段值的序列化字节上界。超过的值回成一段截短的字符串（前 1,000 个字符加「…」）：
+     * 图表只用数值，表格与看板的格子本来就只显示短文本。
+     */
+    maxFieldValueBytes: 4096,
 };
+/**
+ * 按点路径从一条 report item 里取值："timing.after"、"rounds.0.ms"（docs/execution-engine.md
+ * 「Reading the journal」）。
+ *
+ * 这是**协议上的契约**，不只是渲染器的工具函数：看板取数时 CLI 在 SQLite 里按同一套规则把
+ * 字段取出来（adapters 的 dwf-journal-fields.ts），渲染器拿到的值必须与它自己从整条 item 里
+ * 取出来的逐字相同。规则：按 `.` 切段；当前值是数组时，段按 `Number(段)` 当下标（非负整数且
+ * 在界内才算）；是对象时按键取；走不通（null、标量、越界、缺键）得 `undefined`。
+ */
+export function readWorkflowArtifactField(item, path) {
+    let cursor = item;
+    for (const segment of path.split(".")) {
+        if (cursor === null || cursor === undefined)
+            return undefined;
+        if (Array.isArray(cursor)) {
+            const index = Number(segment);
+            if (!Number.isInteger(index) || index < 0 || index >= cursor.length)
+                return undefined;
+            cursor = cursor[index];
+            continue;
+        }
+        if (typeof cursor !== "object")
+            return undefined;
+        cursor = cursor[segment];
+    }
+    return cursor;
+}
 /**
  * 一个产物版本的**元数据**（journal `dwf_node.result_json` 上 `ArtifactVersionRecord` 的
  * zod 镜像）。字节不在这里——`uri` 指向 tool-artifact store，取字节走
@@ -110,7 +153,7 @@ export const workflowRunArtifactSchema = z
  * `workflowRunArtifactRead` 取字节）按需拉——权威始终在 journal。
  *
  * `itemCount` 在这里的职责是**刷新信号**：看板 hook 见它变化就带 `afterSequence` 增量取数。
- * 把标签 report 的原值放进快照会让 256 条 × 32KB 的最坏情形把状态帧撑到 2MB。
+ * 把标签 report 的原值放进这个高频状态键，一个 run 的条目有多少字节，每一帧就要搬多少字节。
  */
 export const workflowRunArtifactSummarySchema = z
     .object({
@@ -154,6 +197,18 @@ export const v4ConversationWorkflowRunArtifactDataParamsSchema = z
     afterSequence: z.number().int().nonnegative().optional(),
     /** 缺省 200、钳 [1, 500]——两者都在网关侧执行（存储层不得自造页大小，也不得再钳）。 */
     limit: z.number().int().positive().max(WORKFLOW_ARTIFACT_LIMITS.maxItemsPerPage).optional(),
+    /**
+     * 只取这些字段路径（{@link readWorkflowArtifactField} 的规则），而不是整条 item：看板只读
+     * spec 里点名的字段，一条 1 MiB 的 item 不该为了一个数被整条搬进渲染器。给了它，结果每条
+     * 带 `fields` 而不带 `item`。缺省 = 整条 item（老渲染器的形状）。
+     *
+     * 偏斜：老 CLI 的 strict schema 不认这个键、整条请求被拒；渲染器据此退回不带它重试。
+     */
+    fields: z
+        .array(z.string().min(1).max(WORKFLOW_ARTIFACT_LIMITS.maxFieldPathLength))
+        .min(1)
+        .max(WORKFLOW_ARTIFACT_LIMITS.maxFieldsPerRequest)
+        .optional(),
 })
     .strict();
 export const v4ConversationWorkflowRunArtifactDataResultSchema = z
@@ -168,13 +223,18 @@ export const v4ConversationWorkflowRunArtifactDataResultSchema = z
         /**
          * 条目原值，**不做预览序列化**：看板的纯函数要按字段路径取数
          * （`ChartSpec.x.field` 形如 "timing.after"），拿到一段 pretty JSON 文本就没法取了。
-         * 单条在线上已由 `REPORT_CAPS.maxItemSerializedBytes`（32KB）与事件载荷有界化
-         * 双重保证，这里不再叠一层界。
+         * 单条由写入侧的 `REPORT_CAPS.maxItemSerializedBytes` 有界，一页由
+         * `WORKFLOW_ARTIFACT_LIMITS.maxPageBytes` 有界。请求带 `fields` 时缺席。
          */
         item: z.unknown(),
+        /**
+         * 请求带 `fields` 时：路径 → 值。走不通的路径不在表里（= `undefined`）；超过
+         * `maxFieldValueBytes` 的值是一段截短的字符串。
+         */
+        fields: z.record(z.string(), z.unknown()).optional(),
     })
         .strict()),
-    /** 本页取满 limit 且后面仍有条目（网关多取一条判定）。 */
+    /** 本页之后仍有条目（页可能因条数或字节上界提前收尾；由存储层判定）。 */
     hasMore: z.boolean(),
 })
     .strict();

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-command-rejections.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const savedWorkflowStartRejectionReasonSchema: z.ZodEnum<{
+    not_found: "not_found";
+    invalid_name: "invalid_name";
+    compile_failed: "compile_failed";
+    start_failed: "start_failed";
+    invalid_args: "invalid_args";
+    session_busy: "session_busy";
+}>;
+export type SavedWorkflowStartRejectionReason = z.infer<typeof savedWorkflowStartRejectionReasonSchema>;
+export declare const SAVED_WORKFLOW_START_REJECTED_FAULT_PREFIX: "fault.command.savedWorkflowStartRejected.";
+export declare const WORKFLOW_RUN_RESUME_REJECTED_FAULT_PREFIX: "fault.command.workflowRunResumeRejected.";
+//# sourceMappingURL=workflow-command-rejections.d.ts.map

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-command-rejections.js

@@ -0,0 +1,23 @@
+// 动态工作流命令的拒绝词表与 fault 前缀：从 command.ts 拆出（该文件在 max-lines 上限），
+// 由 command.ts 再导出，既有导入路径不变。
+import { z } from "zod";
+// startSavedWorkflow 拒绝词表（docs/dynamic-workflow/launch.md「On the agent」）：
+// bootstrap handler 铸造 fault code，ui launcher 反查 i18n 文案，两侧共享此枚举避免漂移。
+// invalid_name / not_found：解析阶段；invalid_args：实参校验；compile_failed：analyzeScript 诊断；
+// session_busy：会话有活动 turn；start_failed：port.submit 之前的其它启动失败。
+export const savedWorkflowStartRejectionReasonSchema = z.enum([
+    "invalid_name",
+    "not_found",
+    "invalid_args",
+    "compile_failed",
+    "session_busy",
+    "start_failed",
+]);
+// 完整 fault code = 前缀 + reason（如 fault.command.savedWorkflowStartRejected.not_found）。
+// 与 workflowRunResumeRejected 命名空间同族；导出常量供 bootstrap 拼接、ui 前缀匹配。
+export const SAVED_WORKFLOW_START_REJECTED_FAULT_PREFIX = "fault.command.savedWorkflowStartRejected.";
+// resumeWorkflowRun 的拒绝：前缀 + 端口 reason（not_found / not_resumable / superseded /
+// already_running / script_missing / script_mismatch / compile_failed）；`ack.message` 携带
+// compile_failed 的有界诊断（docs/dynamic-workflow/presentation.md「The run pane」）。
+export const WORKFLOW_RUN_RESUME_REJECTED_FAULT_PREFIX = "fault.command.workflowRunResumeRejected.";
+//# sourceMappingURL=workflow-command-rejections.js.map

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-observation-display.d.ts

@@ -7,17 +7,17 @@ export declare const toolCallGetWorkflowRunDisplaySchema: z.ZodObject<{
     runId: z.ZodString;
     label: z.ZodString;
     status: z.ZodEnum<{
-        pending: "pending";
         running: "running";
         completed: "completed";
-        stopped: "stopped";
+        pending: "pending";
         errored: "errored";
+        stopped: "stopped";
     }>;
     stopReason: z.ZodOptional<z.ZodEnum<{
-        interrupted: "interrupted";
-        user: "user";
-        model: "model";
         provider: "provider";
+        model: "model";
+        user: "user";
+        interrupted: "interrupted";
         superseded: "superseded";
     }>>;
     possiblyInterrupted: z.ZodOptional<z.ZodBoolean>;
@@ -50,11 +50,11 @@ export declare const toolCallGetWorkflowRunDisplaySchema: z.ZodObject<{
         name: z.ZodOptional<z.ZodString>;
         state: z.ZodEnum<{
             failed: "failed";
-            done: "done";
-            unfinished: "unfinished";
             idle: "idle";
-            executing: "executing";
             waiting: "waiting";
+            executing: "executing";
+            done: "done";
+            unfinished: "unfinished";
             parked: "parked";
         }>;
         phaseName: z.ZodOptional<z.ZodString>;
@@ -117,21 +117,21 @@ export declare const toolCallListWorkflowRunsDisplaySchema: z.ZodObject<{
         runId: z.ZodString;
         label: z.ZodString;
         labelSource: z.ZodEnum<{
-            script: "script";
             name: "name";
+            script: "script";
         }>;
         status: z.ZodEnum<{
-            pending: "pending";
             running: "running";
             completed: "completed";
-            stopped: "stopped";
+            pending: "pending";
             errored: "errored";
+            stopped: "stopped";
         }>;
         stopReason: z.ZodOptional<z.ZodEnum<{
-            interrupted: "interrupted";
-            user: "user";
-            model: "model";
             provider: "provider";
+            model: "model";
+            user: "user";
+            interrupted: "interrupted";
             superseded: "superseded";
         }>>;
         ownedByThisSession: z.ZodBoolean;

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-row-meta.d.ts

@@ -3,14 +3,14 @@ export declare const workflowNotificationMetaSchema: z.ZodDiscriminatedUnion<[z.
     kind: z.ZodLiteral<"terminal">;
     status: z.ZodEnum<{
         completed: "completed";
-        stopped: "stopped";
         errored: "errored";
+        stopped: "stopped";
     }>;
     stopReason: z.ZodOptional<z.ZodEnum<{
-        interrupted: "interrupted";
-        user: "user";
-        model: "model";
         provider: "provider";
+        model: "model";
+        user: "user";
+        interrupted: "interrupted";
         superseded: "superseded";
     }>>;
     summary: z.ZodString;
@@ -51,6 +51,18 @@ export declare const workflowNotificationMetaSchema: z.ZodDiscriminatedUnion<[z.
     question: z.ZodString;
     context: z.ZodOptional<z.ZodString>;
     askedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"hole">;
+    siteId: z.ZodString;
+    ordinal: z.ZodNumber;
+    name: z.ZodString;
+    type: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+    draftPath: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    before: z.ZodOptional<z.ZodString>;
+    after: z.ZodOptional<z.ZodString>;
+    reachedAt: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"stall">;
     sinceMs: z.ZodNumber;
@@ -70,14 +82,14 @@ export declare const backgroundResultOriginMetaSchema: z.ZodObject<{
         kind: z.ZodLiteral<"terminal">;
         status: z.ZodEnum<{
             completed: "completed";
-            stopped: "stopped";
             errored: "errored";
+            stopped: "stopped";
         }>;
         stopReason: z.ZodOptional<z.ZodEnum<{
-            interrupted: "interrupted";
-            user: "user";
-            model: "model";
             provider: "provider";
+            model: "model";
+            user: "user";
+            interrupted: "interrupted";
             superseded: "superseded";
         }>>;
         summary: z.ZodString;
@@ -118,6 +130,18 @@ export declare const backgroundResultOriginMetaSchema: z.ZodObject<{
         question: z.ZodString;
         context: z.ZodOptional<z.ZodString>;
         askedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"hole">;
+        siteId: z.ZodString;
+        ordinal: z.ZodNumber;
+        name: z.ZodString;
+        type: z.ZodString;
+        prompt: z.ZodOptional<z.ZodString>;
+        draftPath: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+        before: z.ZodOptional<z.ZodString>;
+        after: z.ZodOptional<z.ZodString>;
+        reachedAt: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"stall">;
         sinceMs: z.ZodNumber;
@@ -166,6 +190,7 @@ export declare const workflowLaunchMetaSchema: z.ZodObject<{
                 kind: z.ZodEnum<{
                     ask: "ask";
                     "world-read": "world-read";
+                    hole: "hole";
                 }>;
                 label: z.ZodString;
                 labelPattern: z.ZodOptional<z.ZodObject<{
@@ -182,6 +207,7 @@ export declare const workflowLaunchMetaSchema: z.ZodObject<{
                     stack: "stack";
                     serial: "serial";
                 }>>;
+                fill: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>;
             lanes: z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
@@ -216,17 +242,35 @@ export declare const workflowLaunchMetaSchema: z.ZodObject<{
                 line: z.ZodOptional<z.ZodNumber>;
                 column: z.ZodOptional<z.ZodNumber>;
                 alongside: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                fill: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>>;
             phaseEdges: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 from: z.ZodString;
                 to: z.ZodString;
                 back: z.ZodOptional<z.ZodLiteral<true>>;
             }, z.core.$strict>>>;
+            phaseStreams: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strict>>>;
+            holes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                siteId: z.ZodString;
+                name: z.ZodString;
+                type: z.ZodString;
+                phase: z.ZodOptional<z.ZodString>;
+                tail: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>>;
             exits: z.ZodOptional<z.ZodArray<z.ZodString>>;
             sink: z.ZodOptional<z.ZodArray<z.ZodString>>;
             truncated: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>>;
         truncated: z.ZodOptional<z.ZodBoolean>;
+        fill: z.ZodOptional<z.ZodObject<{
+            siteId: z.ZodString;
+            name: z.ZodString;
+            draftPath: z.ZodOptional<z.ZodString>;
+            line: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>>;
     script: z.ZodOptional<z.ZodString>;
     amend: z.ZodOptional<z.ZodObject<{

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-row-meta.js

@@ -60,6 +60,23 @@ export const workflowNotificationMetaSchema = z.discriminatedUnion("kind", [
         context: z.string().max(4000).optional(),
         askedAt: z.number().optional(),
     }),
+    // 留白（docs/dynamic-workflow/transcript-and-notifications.md「The payload」的 `hole` 种类）：run 走到一个
+    // 开着的 `hole<T>()`，那条分支停驻、主代理欠一段代码。`type` 是作者写的类型原文（`Plan`）；`before` /
+    // `after` 是留白两侧的阶段名；`draftPath` / `line` 指向草稿文件里留白所在的那一行。prompt 与升级问题
+    // 同一条 4000 上界，发射侧先截。与契约同名（apps/dcode-cli contracts 侧手工镜像）。
+    z.object({
+        kind: z.literal("hole"),
+        siteId: z.string().min(1).max(64),
+        ordinal: z.number().int().nonnegative(),
+        name: z.string().min(1).max(128),
+        type: z.string().min(1).max(128),
+        prompt: z.string().max(4000).optional(),
+        draftPath: z.string().max(1024).optional(),
+        line: z.number().int().positive().optional(),
+        before: z.string().max(128).optional(),
+        after: z.string().max(128).optional(),
+        reachedAt: z.number().optional(),
+    }),
     // run 级停滞：每个 stall 段一条，不是终态。
     z.object({
         kind: z.literal("stall"),
@@ -93,12 +110,14 @@ const workflowSubagentModelTextSchema = z
 // 设置轮：用户在 run 卡 / 详情页的「配置」里
 // 改了设置，agent 以同一份脚本修订出新 run，并用一条与直接启动同形的 controlOnly 轮记下这件事。
 // 这一块说**改了什么**：只有改动过的设置在场；每一项的 from / to 缺一端即那一端是默认
-// （模型 = 会话模型，上限 = 本机上限）。`ceiling` 是本机上限，供「13 → 4」这种读法。
+// （模型 = 会话模型，上限 = 默认并发）。`ceiling` 是默认并发 D（键名早于「默认并发」，为兼容旧端保留），
+// 供「默认 13 → 4」这种读法。
 export const workflowSettingsAmendMetaSchema = z.object({
-    // 修订自哪个 run。**缺席 = 就地生效**：只改并发上限、run
+    // 修订自哪个 run。**缺席 = 就地生效**（docs/dynamic-workflow/concurrency.md）：只改并发上限、run
     // 又在飞时，那次「配置」不停这次 run、也不另起一次，于是没有前驱可指——`runId` 指的就是被调整的
     // 那一个。渲染端据此只出那一行、不再出卡（同一条 run 画两张卡会读成两次运行）。
-    // 此字段为可选；生产者和消费者需使用一致的 schema 才能解析就地调整的设置记录。
+    // 记录在案的偏斜（与下方 scope / path 同一档）：旧桌面上它是必填，就地生效的设置轮在那里 parse
+    // 失败、整行被丢——丢的是一行记录，run 卡与运行本身不受影响。
     predecessorRunId: z.string().min(1).max(128).optional(),
     subagentModel: z
         .object({

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-run-settings-command.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 /**
- * 命令载荷。两项设置守工具的同一条三态规则：省略 = 沿用，`null` = 回到默认（会话模型 / 本机上限），
+ * 命令载荷。两项设置守工具的同一条三态规则：省略 = 沿用，`null` = 回到默认（会话模型 / 默认并发），
  * 值 = 设定。GUI 只发用户改过的那几项。刻意不携 baseRevision：与 cancelBackgroundWork /
  * resumeWorkflowRun 同类（workflowRuns 面免 revision）。
  */
@@ -26,12 +26,12 @@ export declare const amendWorkflowRunSettingsResultSchema: z.ZodObject<{
  * 是命令自己的检查，missing_boundaries 是端口预检，start_failed 是端口缺席或抛错。
  */
 export declare const workflowRunSettingsRejectionReasonSchema: z.ZodEnum<{
-    unchanged: "unchanged";
     not_found: "not_found";
-    not_configurable: "not_configurable";
+    unchanged: "unchanged";
     script_missing: "script_missing";
-    model_unavailable: "model_unavailable";
     compile_failed: "compile_failed";
+    not_configurable: "not_configurable";
+    model_unavailable: "model_unavailable";
     missing_boundaries: "missing_boundaries";
     start_failed: "start_failed";
 }>;

package/node_modules/@dcode/shared/dist/dcode-protocol-v4/workflow-run-settings-command.js

@@ -6,7 +6,7 @@
 import { z } from "zod";
 import { WORKFLOW_RUNS_LIMITS } from "./workflow-runs.js";
 /**
- * 命令载荷。两项设置守工具的同一条三态规则：省略 = 沿用，`null` = 回到默认（会话模型 / 本机上限），
+ * 命令载荷。两项设置守工具的同一条三态规则：省略 = 沿用，`null` = 回到默认（会话模型 / 默认并发），
  * 值 = 设定。GUI 只发用户改过的那几项。刻意不携 baseRevision：与 cancelBackgroundWork /
  * resumeWorkflowRun 同类（workflowRuns 面免 revision）。
  */
@@ -20,7 +20,7 @@ export const amendWorkflowRunSettingsPayloadSchema = z.object({
         .max(WORKFLOW_RUNS_LIMITS.maxSubagentModelLength)
         .nullable()
         .optional(),
-    /** 同时运行的子代理上限；`null` = 解除本 run 自己的界（回到本机上限）。agent 侧钳到 `[1, 天花板]`。 */
+    /** 同时运行的子代理上限；`null` = 解除本 run 自己的界（回到默认并发）。没有上限：高于默认也行。 */
     maxConcurrency: z.number().int().min(1).nullable().optional(),
 });
 /**

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

@@ -0,0 +1,21 @@
+import type { WorkflowRunActor } from "./workflow-runs.js";
+interface ActorRef {
+    siteId: string;
+    ordinal: number;
+}
+/**
+ * 一条节点事件之后，它点名的子代理的 actor 表（没变即原引用）。
+ *
+ * 只有两种 ask 事件说「这个子代理的转录在哪条会话里」：
+ *   - **缓存命中的结算**：载荷带 `sourceSessionId` 即答案读自前驱的那条会话（导入命中，或修订
+ *     run resume 时对一条导入行的重放）；不带即答案在本 run 里产生过，信封上的 `actorSessionId`
+ *     （本 run 的会话）就是它；
+ *   - **派发**：子代理开始 live 跑，本 run 的会话此刻已经建好——导入过前缀的已经播了种。
+ *
+ * 最后一条说了算。同一个子代理的 ask 按序结算，而导入分歧是单调的：导入命中在前、指向前驱的
+ * 会话；从第一次 live 派发起，本 run 的会话持有全部，抄进来的前缀也在里面。其余事件、没有
+ * actor ref 的事件（world-read）、两个 id 都读不出的老载荷、以及不在表上的子代理：一律不动。
+ */
+export declare function actorsWithTranscriptSession(actors: WorkflowRunActor[], eventType: string, payload: Record<string, unknown>, actorRef: ActorRef | null, envelopeSessionId: string | undefined): WorkflowRunActor[];
+export {};
+//# sourceMappingURL=workflow-runs-actor-session.d.ts.map