@meiyukichan/dsh-sandore 0.1.2-rc.2 → 0.1.2-rc.4

package/cordis.patch.yml

@@ -5,8 +5,13 @@
 #   dsh plugin --profile <name> add @meiyukichan/dsh-sandore
 #
 # 命令会把 `dsh-sandore` 追加进 profile 的 `dsh.profile.bundles` 层栈；启动时
-# profile boot 合并本 patch（单条 `insert` 插件行 + storage 路由），无需手改任何
-# profile 文件。一个命令完成安装与挂载（host 引擎 + client UI + sqlite 持久化）。
+# profile boot 合并本 patch（单条 `insert` 插件行），无需手改任何 profile 文件。
+# 一个命令完成安装与挂载（host 引擎 + client UI + 文件介质持久化）。
+#
+# ⚠️ **本文件与仓库根的 `cordis.yml`（本地 `--patch` overlay）必须同步**：两者都是
+# 「插件行 + storage 配置」的同构层，e2e 进程吃的是**本文件**（临时 profile 走 bundle
+# 通道），本地 dev 吃 `cordis.yml`。历史上两处漂过（`cordis.yml` 改成 json 介质而本文件
+# 仍把 `sandore` 路由到 sqlite ⇒ 真机 e2e 里介质没换、还在写 sqlite）。
 #
 # 行 id 用语义前缀 `sandore`：DSH bundle 的行 id 都是语义前缀（ui-* / tool-* /
 # storage-* 等），`sandore` 唯一且不易与其它 overlay 的 id patch 冲突。
@@ -14,10 +19,12 @@
 # 插件行 name = 本包名（'@meiyukichan/dsh-sandore'）：host 半由 main 提供；client 半经
 # package.json 的 `dsh.client` 声明被 client-modules 扫描发现（exports["./client"]）。
 #
-# storage 路由固化在此：sandore 存储域路由到 sqlite（行级读写，避免 json 后端把
-# 整个 unit 全量重写进 sandore.json 导致膨胀）。`- id: storage-domain` 的 patch
-# 会整行替换该行 config，所以必须同时带 `backend: json`（DSH bundle 默认）。
-# storage-sqlite 包随本包 dependencies 安装（^0.1.2-rc.1，与宿主 rc.1 对齐），profile 可直接解析。
+# ## sandore 存储介质 = DSH `storage-json` 的 `per-record` 布局（本批从 sqlite 迁出）
+# 落点 `~/.dsh/storages/sandore/{definitions,microflows,state}/<id>.json`（一条记录一个文件）。
+# 路由走 **base bundle 的默认 backend（= `json`）** ⇒ 这里**刻意不再有 `storage-domain` 的
+# `routes: {sandore: sqlite}` 那一行**（判据见 `storage-domain/src/index.ts:109` 的
+# `routes?.[name] ?? config.backend`）。**回滚到 sqlite** = 把下面注释掉的 `storage-domain`
+# 段加回来（`storage-sqlite` 行仍插着；sqlite 后端**完全不看 `layout` 与记录戳**，两套介质可并存）。
 
 - insert:
     - id: sandore
@@ -25,15 +32,16 @@
       config:
         defaultTimeoutMs: 7200000
         maxConcurrentSteps: 0
+    # sqlite 后端仍挂着（回滚用）；sandore 域当前**不路由**到它。
+    # storage-sqlite 包随本包 dependencies 安装（^0.1.2-rc.1，与宿主 rc.1 对齐），profile 可直接解析。
     - id: storage-sqlite
       name: '@deepseek-ai/dsh-storage-sqlite'
       config:
         path: !!js dshHomePath('storages/sandore.sqlite')
 
-# sandore 持久化走 sqlite：把 sandore 存储域路由到 sqlite 后端，
-# 其余域保持 json 默认不变。
-- id: storage-domain
-  config:
-    backend: json
-    routes:
-      sandore: sqlite
+# 回滚到 sqlite 介质时，把下面这段解除注释（整行替换 storage-domain 的 config）：
+# - id: storage-domain
+#   config:
+#     backend: json
+#     routes:
+#       sandore: sqlite

package/lib/client/DagEditor.d.ts

@@ -2,6 +2,8 @@ import '@xyflow/react/dist/style.css';
 import './reactflow-theme.css';
 import type { TranslateNS } from '@deepseek-ai/dsh-client-ui-slots';
 import type { MicroflowDefinition, MicroflowRecord } from '@meiyukichan/dsh-sandore/schema';
+import { type MergedStep } from './dag-editor-model.ts';
+import { type FlowTarget } from './FlowEditor.tsx';
 import { type SaveDefinition } from './sandore-save.ts';
 import type { WorkflowOverlayFace } from './workflow-face.ts';
 /**
@@ -84,5 +86,26 @@ export declare function MicroflowDescriptionField({ microflow, onChange, t }: {
     readonly onChange: (next: MicroflowDefinition) => void;
     readonly t: TranslateNS<'sandore'>;
 }): import("react").JSX.Element;
+/** Step 完整字段编辑器（标题 + 名称行 + 执行 command + 流控 FlowEditor + 映射 + gates）。 */
+/**
+ * 单个 step 的**详情编辑器**（编排页右栏；F6 起也被「定义流程图」的步骤弹窗复用）。
+ *
+ * ⚠️ **导出它是有意的**：`definition-flow-step-modal.tsx` 要给出与编排页**逐字段一致**的详情
+ * （用户口径：「内容就是工作流编排那里，点击某个 step 后右边的详情的内容」）⇒ 只允许**同一个组件**
+ * 被两处使用，绝不允许在流程弹窗里另写一套「长得像」的表单（那必然漂移）。
+ * 因此它的 props 保持**纯模型 + 回调**（`step` / `stageSteps` / `targets` / `ruleKeys` /
+ * `onChange` / `onRemove`），不带任何 DagEditor 内部状态 ⇒ 弹窗侧可以从「读回来的定义」直接组装。
+ */
+export declare function StepEditor({ step, stageSteps, targets, ruleKeys, onChange, onRemove, t }: {
+    readonly step: MergedStep;
+    /** 当前 Stage 内全部合并 step（含 branches），用于计算回环环上节点。 */
+    readonly stageSteps: readonly MergedStep[];
+    readonly targets: readonly FlowTarget[];
+    /** 工作流级 rules 内容表的键集合（供 step.rules 键引用编辑的勾选项）。 */
+    readonly ruleKeys: readonly string[];
+    readonly onChange: (step: MergedStep) => void;
+    readonly onRemove: () => void;
+    readonly t: TranslateNS<'sandore'>;
+}): import("react").JSX.Element;
 /** 渲染 DagEditor（两层 DAG 画布 + 编辑侧栏 + YAML 预览）。 */
 export declare function DagEditor({ t, initialYaml, initialId, save, onSaved, face, libraryEntry, readonly, setReadonly }: DagEditorProps): import("react").JSX.Element;

package/lib/client/DagEditor.js

@@ -396,7 +396,16 @@ function OutputRow({ item, onChange, onRemove, t }) {
                 }, placeholder: mode === 'path' ? t('editor.field.relativePath') : t('editor.field.regex') }), _jsx(Button, { variant: "ghost", size: "sm", icon: _jsx(IconTrashOutline16, {}), onClick: onRemove, "aria-label": t('editor.remove.item') })] }));
 }
 /** Step 完整字段编辑器（标题 + 名称行 + 执行 command + 流控 FlowEditor + 映射 + gates）。 */
-function StepEditor({ step, stageSteps, targets, ruleKeys, onChange, onRemove, t }) {
+/**
+ * 单个 step 的**详情编辑器**（编排页右栏；F6 起也被「定义流程图」的步骤弹窗复用）。
+ *
+ * ⚠️ **导出它是有意的**：`definition-flow-step-modal.tsx` 要给出与编排页**逐字段一致**的详情
+ * （用户口径：「内容就是工作流编排那里，点击某个 step 后右边的详情的内容」）⇒ 只允许**同一个组件**
+ * 被两处使用，绝不允许在流程弹窗里另写一套「长得像」的表单（那必然漂移）。
+ * 因此它的 props 保持**纯模型 + 回调**（`step` / `stageSteps` / `targets` / `ruleKeys` /
+ * `onChange` / `onRemove`），不带任何 DagEditor 内部状态 ⇒ 弹窗侧可以从「读回来的定义」直接组装。
+ */
+export function StepEditor({ step, stageSteps, targets, ruleKeys, onChange, onRemove, t }) {
     const inputFrom = step.inputFrom ?? [];
     const outputTo = step.outputTo ?? [];
     const passThroughVars = step.passThroughVars ?? [];
@@ -966,7 +975,7 @@ export function DagEditor({ t, initialYaml, initialId, save, onSaved, face, libr
     return (_jsxs("section", { className: css.editor, "aria-label": t('editor.title'), "data-sandore-dag-editor": true, ...(library === undefined ? {} : { 'data-sandore-library-entry': library.id }), children: [_jsxs("header", { className: css.header, children: [_jsx(Tooltip, { label: library?.record.name ?? definition.workflow.name, side: "bottom", delayMs: 500, children: _jsx("span", { className: css.title, children: library?.record.name ?? definition.workflow.name }) }), _jsxs("span", { className: css.headerActions, "data-sandore-top-actions": true, children: [library === undefined ? (_jsxs(_Fragment, { children: [_jsx(Button, { size: "sm", variant: "ghost", icon: _jsx(EyeIcon, {}), onClick: () => { setPreviewOpen(current => !current); }, children: t('editor.preview') }), _jsx(Button, { size: "sm", variant: "ghost", icon: _jsx(IconDownloadOutline16, {}), onClick: exportYaml, children: t('editor.export') }), _jsx(Button, { size: "sm", variant: "ghost", icon: _jsx(IconCopyOutline16, {}), onClick: () => { setImportOpen(true); }, children: t('editor.import') }), _jsx(Button, { size: "sm", variant: "primary", icon: _jsx(IconSparkle16, {}), onClick: () => { setToast(current => ({ seq: (current?.seq ?? 0) + 1, message: t('editor.chatCreate.hint') })); }, children: t('editor.chatCreate') }), id !== undefined && (_jsx(Button, { size: "sm", variant: "primary", icon: _jsx(IconPlayOutline16, {}), onClick: runTest, children: t('editor.test') }))] })) : (_jsx(Button, { size: "sm", variant: "ghost", icon: _jsx(IconCopyOutline16, {}), "data-sandore-library-entry-edit-yaml": true, onClick: library.onEditYaml, children: t('library.edit.yaml') })), _jsx(Button, { size: "sm", variant: "primary", icon: _jsx(IconCheckOutline16, {}), 
                                 /* 库条目**不受只读锁约束**（只读锁的是 workflow id）⇒ 库模式的保存按钮不看 `readonly`；
                                    工作流模式逐字保留原判据。 */
-                                disabled: saveState.kind === 'pending' || (library === undefined && readonly), onClick: () => { void runSave(); }, children: saveState.kind === 'pending' ? t('editor.saving') : t('save') })] })] }), saveState.kind === 'error' && (_jsx("p", { className: css.error, role: "alert", children: saveState.details === undefined
+                                disabled: saveState.kind === 'pending' || (library === undefined && readonly), "data-sandore-dag-save": true, onClick: () => { void runSave(); }, children: saveState.kind === 'pending' ? t('editor.saving') : t('save') })] })] }), saveState.kind === 'error' && (_jsx("p", { className: css.error, role: "alert", children: saveState.details === undefined
                     ? t('editor.save.failed', { message: saveState.message })
                     : t('editor.save.failed', { message: `${saveState.message} — ${saveState.details}` }) })), _jsxs("div", { className: css.canvasRow, children: [_jsxs("div", { className: css.canvas, children: [_jsxs("div", { className: css.canvasTabs, children: [drillMicroflowId !== undefined && !libraryMode && (_jsxs("button", { type: "button", className: css.backBtn, onClick: backToStages, children: ["\u2190 ", t('editor.microflowDag')] })), _jsx("span", { className: css.crumb, children: drillMicroflowId === undefined
                                             ? t('editor.microflowDag')

package/lib/client/FlowView.d.ts

@@ -63,6 +63,13 @@ export interface FlowViewProps {
     readonly width?: number | undefined;
     /** 无障碍标签（缺省用 `workflowId`；不编文案）。 */
     readonly label?: string | undefined;
+    /**
+     * **点击步骤卡片**（F6：弹窗展示/编辑该 step 的详情）。
+     *
+     * 给了它就启用事件委托（`closest('[data-flow-step]')`），并把卡片的
+     * `(microflowId, stepId)` 回调出去；**不给 ⇒ 卡片不可点、DOM 与行为逐字不变**。
+     */
+    readonly onStepOpen?: ((target: FlowStepClickTarget) => void) | undefined;
     /**
      * 文案函数（B4 接线后由调用方给；**缺省仍渲原因码**）。
      *
@@ -71,6 +78,18 @@ export interface FlowViewProps {
      */
     readonly t?: ((key: FlowNoticeKey) => string) | undefined;
 }
+/** 被点开的步骤卡片身份（`microflowId` 可能为空串 = 卡片没带容器身份，调用方自行判空）。 */
+export interface FlowStepClickTarget {
+    readonly microflowId: string;
+    readonly stepId: string;
+}
+/**
+ * 从点击目标上读卡片身份（**事件委托**：卡片是注入进去的字符串、挂不了 React 处理器
+ * ⇒ 只能在 `<svg>` 这一层代理；`theme-tokens.spec.ts` 那条"只许对 inner 用注入"的判据仍然成立）。
+ * @param target - 事件目标（`null` 安全）。
+ * @returns 卡片身份；点的不是卡片 ⇒ undefined。
+ */
+export declare function flowStepTargetOf(target: EventTarget | null): FlowStepClickTarget | undefined;
 /**
  * 同步链路：yaml → 图 → 计划 → SVG（**永不抛**，失败折成 `error` 态）。
  * @param yaml - 定义 yaml。

package/lib/client/FlowView.js

@@ -26,7 +26,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { flowGraphOfYaml } from "./flow-model.js";
-import { FLOW_MIN_WIDTH, flowWidthTier, planFlow } from "./flow-layout.js";
+import { FLOW_MAX_DISPLAY_WIDTH, FLOW_MIN_WIDTH, flowWidthTier, planFlow } from "./flow-layout.js";
 import { renderFlowSvg } from "./flow-render.js";
 import css from './flow-view.module.css';
 /** 原因码 → 文案键（唯一映射表；未知/新增的原因码由类型系统兜住）。 */
@@ -42,6 +42,26 @@ export function flowNoticeKeyOf(reason) {
             return 'definitionFlow.error.noChannel';
     }
 }
+/**
+ * 从点击目标上读卡片身份（**事件委托**：卡片是注入进去的字符串、挂不了 React 处理器
+ * ⇒ 只能在 `<svg>` 这一层代理；`theme-tokens.spec.ts` 那条"只许对 inner 用注入"的判据仍然成立）。
+ * @param target - 事件目标（`null` 安全）。
+ * @returns 卡片身份；点的不是卡片 ⇒ undefined。
+ */
+export function flowStepTargetOf(target) {
+    if (target === null || typeof target !== 'object')
+        return undefined;
+    const element = target;
+    if (typeof element.closest !== 'function')
+        return undefined;
+    const card = element.closest('[data-flow-step]');
+    if (card === null)
+        return undefined;
+    const stepId = card.getAttribute('data-flow-step') ?? '';
+    if (stepId === '')
+        return undefined;
+    return { microflowId: card.getAttribute('data-flow-microflow') ?? '', stepId };
+}
 /**
  * 同步链路：yaml → 图 → 计划 → SVG（**永不抛**，失败折成 `error` 态）。
  * @param yaml - 定义 yaml。
@@ -95,13 +115,21 @@ export function useMeasuredWidth() {
 export function FlowView(props) {
     const [rootRef, measured] = useMeasuredWidth();
     const explicit = props.width !== undefined && Number.isFinite(props.width) ? Math.max(FLOW_MIN_WIDTH, props.width) : undefined;
-    const tier = explicit ?? flowWidthTier(measured);
+    // F5：**渲染宽度封顶 400**（定稿页 `final.html` 的 `figure{width:400px}`）——宽容器只多留白，不把图拉宽。
+    const tier = Math.min(explicit ?? flowWidthTier(measured), FLOW_MAX_DISPLAY_WIDTH);
     const state = useFlowViewState(props.yaml, props.workflowId ?? '', tier);
     const workflowId = props.workflowId ?? (state.state === 'ready' ? state.plan.header.name : '');
     const label = props.label ?? props.workflowId;
     const notices = state.state === 'ready' ? state.plan.notes : [];
+    const onStepOpen = props.onStepOpen;
     // B4：给了文案函数就渲文案，没给仍渲原因码（B3 的行为逐字不变）。
     const textOf = (key, fallback) => props.t === undefined ? fallback : props.t(key);
-    return (_jsxs("div", { className: css.root, ref: rootRef, "data-sandore-definition-flow": workflowId, "data-definition-flow-state": state.state, "data-definition-flow-width": tier, children: [_jsx("div", { className: css.scroll, children: _jsx("div", { className: css.canvas, style: { minWidth: tier }, children: state.state === 'ready' ? (_jsx("svg", { className: css.svg, viewBox: state.svg.viewBox, width: "100%", role: "img", xmlns: "http://www.w3.org/2000/svg", "data-definition-flow-svg": "", ...(label === undefined ? {} : { 'aria-label': label }), dangerouslySetInnerHTML: { __html: state.svg.inner } })) : null }) }), state.state === 'error' ? (_jsx("div", { className: `${css.notice} ${css.noticeError}`, "data-definition-flow-notice": "", "data-definition-flow-reason": state.reason, role: "alert", children: [textOf(flowNoticeKeyOf(state.reason), state.reason), state.message]
+    return (_jsxs("div", { className: css.root, ref: rootRef, "data-sandore-definition-flow": workflowId, "data-definition-flow-state": state.state, "data-definition-flow-width": tier, ...(onStepOpen === undefined ? {} : { 'data-definition-flow-clickable': '' }), children: [_jsx("div", { className: css.scroll, children: _jsx("div", { className: css.canvas, "data-definition-flow-canvas": "", style: { width: tier }, children: state.state === 'ready' ? (_jsx("svg", { className: css.svg, viewBox: state.svg.viewBox, width: "100%", role: "img", xmlns: "http://www.w3.org/2000/svg", "data-definition-flow-svg": "", ...(onStepOpen === undefined
+                            ? {}
+                            : { onClick: (event) => {
+                                    const hit = flowStepTargetOf(event.target);
+                                    if (hit !== undefined)
+                                        onStepOpen(hit);
+                                } }), ...(label === undefined ? {} : { 'aria-label': label }), dangerouslySetInnerHTML: { __html: state.svg.inner } })) : null }) }), state.state === 'error' ? (_jsx("div", { className: `${css.notice} ${css.noticeError}`, "data-definition-flow-notice": "", "data-definition-flow-reason": state.reason, role: "alert", children: [textOf(flowNoticeKeyOf(state.reason), state.reason), state.message]
                     .filter(part => part !== undefined && part !== '').join(' · ') })) : null, state.state === 'loading' ? (_jsx("div", { className: css.notice, "data-definition-flow-notice": "", children: textOf('definitionFlow.loading', 'loading') })) : null, notices.map(note => (_jsx("div", { className: css.notice, "data-definition-flow-notice": "", children: note }, note)))] }));
 }

package/lib/client/better-sidebar-open.d.ts

@@ -236,7 +236,13 @@ export interface SandoreFileOpenDeps {
      * （`openpath-intercept.ts:23-27` 明说），缓存旧实例会让 shadow 后的新实例被绕过。
      */
     readonly sessionRemote?: (() => SessionRemoteLike | undefined) | undefined;
-    /** host 侧落盘 RPC（写 `<cwd>/.sandore/artifacts/<instanceId>/…`，返回**进程绝对路径**）。 */
+    /**
+     * host 侧落盘 RPC（写 `<DSH_HOME>/storages/sandore/output/<instanceId>/…`，返回**进程绝对路径**）。
+     *
+     * 该落点**在会话 workspace 之外**（本批从 `<cwd>/.sandore/artifacts/` 搬出来）⇒ L3 的越界判据
+     * 对它恒成立，所以 better-sidebar 在场时 Agent 输出一律走自注册 tab（`sandore-tab`），
+     * 不再落进用户的仓库。
+     */
     readonly writeOutput?: ((request: WriteOutputRequest) => Promise<string>) | undefined;
     /** host 侧读文件 RPC（`readInstanceFile`；应用内兜底与 C6 tab 体共用的取数面）。 */
     readonly readFile?: ((request: ReadFileRequest) => Promise<ReadFileResultLike>) | undefined;
@@ -289,8 +295,9 @@ export interface SandoreFileOpenTarget {
      */
     openArtifact(input: OpenArtifactInput): Promise<OpenOutcome>;
     /**
-     * 打开一段 **Agent 输出文本**（result 叶子）：**只有在"至少一条交付通道可用"时**才落盘 ——
-     * 落盘的存在理由就是"`openTab`/编辑器只能打开磁盘上的文件"（见本函数内的完整结论）。
+     * 打开一段 **Agent 输出文本**（result 叶子）：**非空输出一律先落盘**（2026-09-22 真机报障后
+     * 去掉了"先确认能交出去"那道门），再走四段判定链；落盘的存在理由就是
+     * "`openTab`/编辑器只能打开磁盘上的文件"（见本函数内的完整结论）。
      * @returns 四段判定链的 outcome（**永不 undefined**）。
      */
     openOutput(input: OpenOutputInput): Promise<OpenOutcome>;
@@ -453,6 +460,24 @@ export declare function resolveSidebarPath(cwd: string | undefined, path: string
 export declare function isWithinWorkspace(cwd: string | undefined, path: string): boolean;
 /** 取路径末段（文件标题兜底；两侧分隔符都认）。 */
 export declare function baseNameOf(path: string): string;
+/**
+ * **纯函数**：这个绝对路径是不是**我们自己的 Agent 输出落点**
+ * （`<DSH_HOME>/storages/sandore/output/<instanceId>/<stepId>-<attemptIndex>-output.md`）。
+ *
+ * 为什么要一个"机器可判"的标记（2026-09-22 真机报障的根因之一）：这个落点由 host 唯一构造
+ * （`instance-output.ts::outputDirPath`），**恒在会话 workspace 之外**；而 better-sidebar 的
+ * editor tab 读文件走它自己的 `/sidebar/api/fs.read`，**带 workspace fence**
+ * （0.18.0 `workspaceFence` 默认开 → `assertWithinWorkspace`，fence 根 = 落点会话 header 的 cwd）
+ * ⇒ 把 Agent 输出交给它的编辑器，只会换来它自己的 403/空白页 —— 我们这边又按"已交出去"清掉了
+ * 应用内预览 ⇒ **用户看到"点了没反应"**。
+ *
+ * `chain` 的 P14 例外（`ownerIsLanding` ⇒ 不判越界）是为**产物文件**写的（那种路径按会话 cwd
+ * 拼出来 ⇒ 必然在里面），**不能套到 Agent 输出上**：后者是"我们自己数据目录里的文件"，
+ * 与会话 workspace 无关。有了这个标记就**不必依赖**客户端那份可能缺失/落后的 cwd 摘要。
+ * @param path - 目标绝对路径（相对路径一律 false）。
+ * @returns 是否落在 sandore 的 Agent 输出落点目录下。
+ */
+export declare function isSandoreOutputPath(path: string): boolean;
 /** 取当前装配的打开面（未装配 ⇒ `undefined`，调用方仍必须给出可见结果）。 */
 export declare function getSandoreFileOpen(): SandoreFileOpenTarget | undefined;
 /**

package/lib/client/better-sidebar-open.js

@@ -157,6 +157,26 @@ export function baseNameOf(path) {
     const index = unified.lastIndexOf('/');
     return index === -1 ? unified : unified.slice(index + 1);
 }
+/**
+ * **纯函数**：这个绝对路径是不是**我们自己的 Agent 输出落点**
+ * （`<DSH_HOME>/storages/sandore/output/<instanceId>/<stepId>-<attemptIndex>-output.md`）。
+ *
+ * 为什么要一个"机器可判"的标记（2026-09-22 真机报障的根因之一）：这个落点由 host 唯一构造
+ * （`instance-output.ts::outputDirPath`），**恒在会话 workspace 之外**；而 better-sidebar 的
+ * editor tab 读文件走它自己的 `/sidebar/api/fs.read`，**带 workspace fence**
+ * （0.18.0 `workspaceFence` 默认开 → `assertWithinWorkspace`，fence 根 = 落点会话 header 的 cwd）
+ * ⇒ 把 Agent 输出交给它的编辑器，只会换来它自己的 403/空白页 —— 我们这边又按"已交出去"清掉了
+ * 应用内预览 ⇒ **用户看到"点了没反应"**。
+ *
+ * `chain` 的 P14 例外（`ownerIsLanding` ⇒ 不判越界）是为**产物文件**写的（那种路径按会话 cwd
+ * 拼出来 ⇒ 必然在里面），**不能套到 Agent 输出上**：后者是"我们自己数据目录里的文件"，
+ * 与会话 workspace 无关。有了这个标记就**不必依赖**客户端那份可能缺失/落后的 cwd 摘要。
+ * @param path - 目标绝对路径（相对路径一律 false）。
+ * @returns 是否落在 sandore 的 Agent 输出落点目录下。
+ */
+export function isSandoreOutputPath(path) {
+    return normalizeForCompare(path).includes('/storages/sandore/output/');
+}
 /** 模块级单例（组件树不携带 ctx；与 `installStepChatSessions` 同法）。 */
 let installed;
 /** 自注册 tab 的通用打开面（与 `installed` **同一处装配/卸载**：两者共享一个闭包）。 */
@@ -490,9 +510,20 @@ export function installSandoreFileOpen(deps) {
              *   编辑器只会渲染它自己的 403 空壳 ⇒ 仍然跳过 L1/L2 走 L3（P13 的跨 workspace 正解不变）。
              */
             const ownerIsLanding = request.instanceId !== '' && request.instanceId === landing.sessionId;
-            const outside = !ownerIsLanding
-                && landing.cwd !== undefined
-                && !isWithinWorkspace(landing.cwd, request.absolute);
+            /*
+             * Agent 输出落点：**机器可判地在 workspace 之外** ⇒ 直接判越界（跳过 L1/L2，交给 L3）。
+             *
+             * 为什么必须单独判（2026-09-22 真机报障）：下面那条 P14 例外把"产物属于落点会话"当成
+             * "路径必然在该会话 workspace 内"——那对**产物文件**成立（相对会话 cwd 拼出来），
+             * 但 Agent 输出自从搬到 `<DSH_HOME>/storages/sandore/output/` 之后**恒在外面**，
+             * 而且 `instanceId === landing.sessionId` 恰恰是**最常见**的情形（你就在看这个实例的会话）。
+             * ⇒ 落进 L1/L2：better-sidebar 的编辑器受自己的 workspace fence（默认开）拒绝，渲染 403/空白，
+             * 我们这边又以为"已经交出去了"而**不渲染应用内视图** ⇒ 用户看到"点了没反应"。
+             */
+            const outside = isSandoreOutputPath(request.absolute)
+                || (!ownerIsLanding
+                    && landing.cwd !== undefined
+                    && !isWithinWorkspace(landing.cwd, request.absolute));
             if (outside) {
                 attempt({
                     kind: 'unusable',
@@ -556,7 +587,7 @@ export function installSandoreFileOpen(deps) {
         return outcomeOf(read.reason, content);
     };
     /**
-     * **是否可以"交出去"**（同步判据；落盘门与 `sidebarAvailable()` 共用）。
+     * **是否可以"交出去"**（同步判据；`sidebarAvailable()` 用；**不再参与落盘门**——见 `openOutput`）。
      *
      * 它回答的是"有没有落点"：有落点会话 ∧（漏斗成员在场 ∨ editor tab 可用 ∨ 自注册 tab 可用）。
      * 注意这是**必要条件**而不是承诺：真正交出去还要过 L1 的信封/探针与 L3 的注册表，所以
@@ -677,21 +708,22 @@ export function installSandoreFileOpen(deps) {
                 return outcomeOf('empty-text', content);
             }
             /*
-             * ── 「落盘」这条纪律 ────────────────────────────────────────────────────────────
+             * ── 「落盘」这条纪律（**2026-09-22 真机报障后改口径**）────────────────────────────
              * 存在理由：**`openTab` / 编辑器 tab 只能打开磁盘上的文件** —— `seed.path` 就是 tab 的
              * 内容种子（0.18.0 `SidebarTab.path`；0.19.x 的资源地址也由 path 编成）。Agent 输出只在
              * 内存里，不落盘就没有 path ⇒ 只能自家渲染 ⇒ 正是用户不接受的那件事。
-             * 触发条件：**确认至少有一条落点通道**（`canHandOff`）。它不成立（服务缺席 / 无活跃会话 /
-             * 无 openTab / 无漏斗）⇒ **零写盘**，直接用内存文本走 L4。
-             * 为什么这不算"偷偷写文件"：① 落点固定（`<cwd>/.sandore/artifacts/<instanceId>/`）；
-             * ② 文件名由 step/attempt 派生 ⇒ **重复点击是覆盖，不是堆积**；③ 写的是用户**刚刚点击**
-             * 要看的那一段输出（不是后台产物）。
+             *
+             * **旧口径（已废）**：只有 `canHandOff()` 为真（有落点会话 ∧ 漏斗/编辑器/自注册 tab 至少一条）
+             * 才落盘。真机后果：**用户点「Agent 输出」后 `<DSH_HOME>/storages/sandore/output/` 压根没被创建**
+             * —— 用户据此直接问"是不是没把这个文件放到 output 目录"。而且落盘还有独立价值：
+             * ① 那是**用户的证据**（他自己也能去目录里找）；② tab 的 `meta.path` 随布局持久化，
+             * 刷新后靠它重建内容；③ 与应用内兜底视图共用同一个原因行里的路径。
+             *
+             * **新口径**：**非空**输出 ⇒ **一律落盘**（零 gate），然后再走四段判定链；链上全不成 ⇒
+             * 应用内展示（内容来自内存文本，路径来自刚落盘的那个文件）。**空文本仍然不落盘**（决策 D4
+             * 不变：没有输出就没有文件，给中性提示）。落点固定在我们自己的数据目录、文件名由 step/attempt
+             * 派生 ⇒ 重复点击是覆盖，不是堆积。
              */
-            if (!canHandOff()) {
-                const failure = landingFailureOf();
-                const content = artifactContentOf({ kind: 'result', name, text: input.text, reason: failure.reason, message: failure.message });
-                return outcomeOf(failure.reason, content);
-            }
             let written;
             try {
                 const writeOutput = deps.writeOutput;

package/lib/client/dag-editor-model.d.ts

@@ -40,7 +40,14 @@ export type CommandType = CommandConfig['type'];
 export declare const COMMAND_TYPES: readonly CommandType[];
 /** 生成带前缀的唯一 id（`{prefix}-{uuid}`），供 Stage/Step/ipt/opt 节点复用。 */
 export declare function newId(prefix: string): string;
-/** 构造一个新的空 microflow 定义（唯一 `stg-{uuid}` id + 空 steps；D8：id 前缀沿用现有生成器）。 */
+/**
+ * 构造一个新的空 microflow 定义（唯一 `mfl-{uuid}` id + 空 steps）。
+ *
+ * ★ **前缀 = `mfl-`**（用户口径，2026-09-21 定稿）：`microflow` 重构（D4b）之后对外**零别名**都叫
+ * microflow，id 前缀却还留着旧词 `stg-`（stage）——那是历史遗留，现已改成 `mfl-`。
+ * **只管"新铸的 id"**：既有数据里的 `stg-…` id 是**不透明字符串**（没有任何代码解析前缀），
+ * 照旧合法、**不要**去批量改写它们（改 id 等于改介质契约）。
+ */
 export declare function createMicroflow(name: string): MicroflowDefinition;
 /** 构造一个新的空 microflow 定义（旧名保留为别名，语义相同）。 */
 export declare const createStage: typeof createMicroflow;

package/lib/client/dag-editor-model.js

@@ -37,9 +37,16 @@ export const COMMAND_TYPES = ['shell', 'prompt', 'agent', 'skill', 'mcp'];
 export function newId(prefix) {
     return `${prefix}-${globalThis.crypto.randomUUID()}`;
 }
-/** 构造一个新的空 microflow 定义（唯一 `stg-{uuid}` id + 空 steps；D8：id 前缀沿用现有生成器）。 */
+/**
+ * 构造一个新的空 microflow 定义（唯一 `mfl-{uuid}` id + 空 steps）。
+ *
+ * ★ **前缀 = `mfl-`**（用户口径，2026-09-21 定稿）：`microflow` 重构（D4b）之后对外**零别名**都叫
+ * microflow，id 前缀却还留着旧词 `stg-`（stage）——那是历史遗留，现已改成 `mfl-`。
+ * **只管"新铸的 id"**：既有数据里的 `stg-…` id 是**不透明字符串**（没有任何代码解析前缀），
+ * 照旧合法、**不要**去批量改写它们（改 id 等于改介质契约）。
+ */
 export function createMicroflow(name) {
-    return { id: newId('stg'), name, steps: [] };
+    return { id: newId('mfl'), name, steps: [] };
 }
 /** 构造一个新的空 microflow 定义（旧名保留为别名，语义相同）。 */
 export const createStage = createMicroflow;
@@ -175,7 +182,7 @@ export const NEW_DEFINITION_ID = 'wfl-new';
  * @returns 最小合法定义。
  */
 export function createBlankDefinition(id = NEW_DEFINITION_ID) {
-    const microflowId = newId('stg');
+    const microflowId = newId('mfl');
     return {
         workflow: {
             id,

package/lib/client/definition-flow-open.d.ts

@@ -27,6 +27,21 @@
  * ## 幂等
  * 打开动作按 **`callId`** 记在模块级 `Set`（同一工具行重渲/重挂不再开；`dedupeKey` 兜住
  * "同一定义只留一个 tab"）。两条都由本模块的 `definitionFlowTabOpenAlready` 与 spec 锁住。
+ *
+ * ## 「打开意图」版本号（2026-09-22 真机报障：**右边那张图只渲染一次**）
+ * 现象：模型连着调了好几次 `visualize`（回执 `stepCount` 从 0 一路变到 17），侧栏那张图**始终是
+ * 第一次**的样子。
+ *
+ * 根因（**不在我们这侧**）：better-sidebar 0.18.0 的 `applyDedupe`（`service.ts:842-865`）在
+ * `dedupeKey` 命中已有 tab 时**只 `activateTabReducer` 聚焦**——新 `seed` 整条被丢弃、tab 体
+ * **不重挂**、`meta` 也不刷新。而本 tab 体唯一的"重取开关"是它自己的 `revision` 计数器
+ * （初值 0，只被步骤弹窗保存 +1）⇒ 第二次起 `useEffect` 的依赖逐值不变 ⇒ **永不重取**。
+ * 侧栏在场时行内图**又不渲染**（`definition-flow-tool-card.tsx` 的 `handedOff`）⇒ 一个可见面都不更新。
+ *
+ * 处置：本模块记一个**按 `workflowId` 分桶的「打开意图」计数**，**每次成功把图交给侧栏**
+ * （`result.kind === 'opened'`，**含"聚焦已有 tab"那一路**）就 +1 并通知订阅者；tab 体用
+ * `useSyncExternalStore` 读它、与本地保存计数相加当取数开关（见 `definition-flow-tab.tsx`）。
+ * 这样"模型又画了一次"就一定会让那张图重取，而**不需要**动 host / wire / typert / SSE 契约。
  * @module @deepseek-ai/dsh-client-ui-sandore/src/client/definition-flow-open
  */
 import { type SandoreTabOpenReason } from './better-sidebar-open.ts';
@@ -79,13 +94,36 @@ export interface DefinitionFlowOpenInput {
      */
     readonly callId?: string | undefined;
 }
+/**
+ * 读某份定义的「打开意图」计数（没有记录 ⇒ 0）。
+ * @param workflowId - 定义 id。
+ * @returns 该定义被"打开/聚焦"过多少次（从进程启动起算）。
+ */
+export declare function definitionFlowRevisionOf(workflowId: string): number;
+/**
+ * 订阅「打开意图」计数变化。
+ * @param listener - 变化回调（`useSyncExternalStore` 的 subscribe 参数）。
+ * @returns 取消订阅。
+ */
+export declare function subscribeDefinitionFlowRevision(listener: () => void): () => void;
+/**
+ * 给某份定义的「打开意图」计数 +1 并通知订阅者（**永不抛**：单个订阅者出错不影响其它人）。
+ * @param workflowId - 定义 id。
+ * @returns 新的计数。
+ */
+export declare function bumpDefinitionFlowRevision(workflowId: string): number;
 /**
  * 这次工具调用**已经**把 tab 开过了吗（幂等门）。
  * @param callId - 工具调用 id。
  * @returns 是否已开过。
  */
 export declare function definitionFlowTabOpenAlready(callId: string): boolean;
-/** 清空幂等门（**只给单测**：模块级状态不能跨用例泄漏）。 */
+/**
+ * 清空幂等门与「打开意图」计数（**只给单测**：模块级状态不能跨用例泄漏）。
+ *
+ * 通知订阅者但**不回退**计数语义：tab 体只对**递增**做出反应（见 `definition-flow-tab.tsx`），
+ * 所以清空对已挂载的组件是**不可见**的，不会凭空触发一次取数。
+ */
 export declare function resetDefinitionFlowOpens(): void;
 /**
  * 打开「定义流程图」tab（**同步、先算后调、永不抛**）。

package/lib/client/definition-flow-open.js

@@ -27,6 +27,21 @@
  * ## 幂等
  * 打开动作按 **`callId`** 记在模块级 `Set`（同一工具行重渲/重挂不再开；`dedupeKey` 兜住
  * "同一定义只留一个 tab"）。两条都由本模块的 `definitionFlowTabOpenAlready` 与 spec 锁住。
+ *
+ * ## 「打开意图」版本号（2026-09-22 真机报障：**右边那张图只渲染一次**）
+ * 现象：模型连着调了好几次 `visualize`（回执 `stepCount` 从 0 一路变到 17），侧栏那张图**始终是
+ * 第一次**的样子。
+ *
+ * 根因（**不在我们这侧**）：better-sidebar 0.18.0 的 `applyDedupe`（`service.ts:842-865`）在
+ * `dedupeKey` 命中已有 tab 时**只 `activateTabReducer` 聚焦**——新 `seed` 整条被丢弃、tab 体
+ * **不重挂**、`meta` 也不刷新。而本 tab 体唯一的"重取开关"是它自己的 `revision` 计数器
+ * （初值 0，只被步骤弹窗保存 +1）⇒ 第二次起 `useEffect` 的依赖逐值不变 ⇒ **永不重取**。
+ * 侧栏在场时行内图**又不渲染**（`definition-flow-tool-card.tsx` 的 `handedOff`）⇒ 一个可见面都不更新。
+ *
+ * 处置：本模块记一个**按 `workflowId` 分桶的「打开意图」计数**，**每次成功把图交给侧栏**
+ * （`result.kind === 'opened'`，**含"聚焦已有 tab"那一路**）就 +1 并通知订阅者；tab 体用
+ * `useSyncExternalStore` 读它、与本地保存计数相加当取数开关（见 `definition-flow-tab.tsx`）。
+ * 这样"模型又画了一次"就一定会让那张图重取，而**不需要**动 host / wire / typert / SSE 契约。
  * @module @deepseek-ai/dsh-client-ui-sandore/src/client/definition-flow-open
  */
 import { getSandoreTabOpener } from "./better-sidebar-open.js";
@@ -53,6 +68,52 @@ export function definitionFlowTabInstanceId(workflowId) {
 }
 /** 已成功打开过的 `callId`（模块级；`resetDefinitionFlowOpens` 只给单测用）。 */
 const openedCallIds = new Set();
+/**
+ * 「打开意图」计数（按 `workflowId` 分桶）。
+ *
+ * 每成功把图交给侧栏（含"聚焦已有 tab"那一路）就 +1 —— 它是 tab 体重取的**唯一**外部信号，
+ * 因为 better-sidebar 在 `dedupeKey` 命中时不换 seed、不重挂、不刷新 `meta`（模块头有根因）。
+ */
+const openRevisions = new Map();
+/** 打开意图计数的订阅者（tab 体经 `useSyncExternalStore` 订阅）。 */
+const openRevisionListeners = new Set();
+/**
+ * 读某份定义的「打开意图」计数（没有记录 ⇒ 0）。
+ * @param workflowId - 定义 id。
+ * @returns 该定义被"打开/聚焦"过多少次（从进程启动起算）。
+ */
+export function definitionFlowRevisionOf(workflowId) {
+    return openRevisions.get(workflowId) ?? 0;
+}
+/**
+ * 订阅「打开意图」计数变化。
+ * @param listener - 变化回调（`useSyncExternalStore` 的 subscribe 参数）。
+ * @returns 取消订阅。
+ */
+export function subscribeDefinitionFlowRevision(listener) {
+    openRevisionListeners.add(listener);
+    return () => {
+        openRevisionListeners.delete(listener);
+    };
+}
+/**
+ * 给某份定义的「打开意图」计数 +1 并通知订阅者（**永不抛**：单个订阅者出错不影响其它人）。
+ * @param workflowId - 定义 id。
+ * @returns 新的计数。
+ */
+export function bumpDefinitionFlowRevision(workflowId) {
+    const next = definitionFlowRevisionOf(workflowId) + 1;
+    openRevisions.set(workflowId, next);
+    for (const listener of [...openRevisionListeners]) {
+        try {
+            listener();
+        }
+        catch (error) {
+            console.warn('[sandore] a definition-flow revision listener threw:', error);
+        }
+    }
+    return next;
+}
 /**
  * 这次工具调用**已经**把 tab 开过了吗（幂等门）。
  * @param callId - 工具调用 id。
@@ -61,9 +122,23 @@ const openedCallIds = new Set();
 export function definitionFlowTabOpenAlready(callId) {
     return callId !== '' && openedCallIds.has(callId);
 }
-/** 清空幂等门（**只给单测**：模块级状态不能跨用例泄漏）。 */
+/**
+ * 清空幂等门与「打开意图」计数（**只给单测**：模块级状态不能跨用例泄漏）。
+ *
+ * 通知订阅者但**不回退**计数语义：tab 体只对**递增**做出反应（见 `definition-flow-tab.tsx`），
+ * 所以清空对已挂载的组件是**不可见**的，不会凭空触发一次取数。
+ */
 export function resetDefinitionFlowOpens() {
     openedCallIds.clear();
+    openRevisions.clear();
+    for (const listener of [...openRevisionListeners]) {
+        try {
+            listener();
+        }
+        catch {
+            /* 单测清理阶段：订阅者抛错无意义，吞掉 */
+        }
+    }
 }
 /**
  * 打开「定义流程图」tab（**同步、先算后调、永不抛**）。
@@ -103,6 +178,9 @@ export function openDefinitionFlowTab(input) {
     if (result.kind === 'opened') {
         if (callId !== '')
             openedCallIds.add(callId);
+        // 「打开意图」+1：**含**"dedupeKey 命中 ⇒ 只聚焦了已有 tab"那一路（那条路上
+        // better-sidebar 不换 seed、不重挂 tab 体 ⇒ 只有这个计数能让那张图重取）。
+        bumpDefinitionFlowRevision(workflowId);
         return { kind: 'sidebar-open' };
     }
     return { kind: 'inline', reason: result.reason, message: result.message };