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

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;

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

@@ -683,9 +683,10 @@ export function installSandoreFileOpen(deps) {
              * 内存里，不落盘就没有 path ⇒ 只能自家渲染 ⇒ 正是用户不接受的那件事。
              * 触发条件：**确认至少有一条落点通道**（`canHandOff`）。它不成立（服务缺席 / 无活跃会话 /
              * 无 openTab / 无漏斗）⇒ **零写盘**，直接用内存文本走 L4。
-             * 为什么这不算"偷偷写文件"：① 落点固定（`<cwd>/.sandore/artifacts/<instanceId>/`）；
-             * ② 文件名由 step/attempt 派生 ⇒ **重复点击是覆盖，不是堆积**；③ 写的是用户**刚刚点击**
-             * 要看的那一段输出（不是后台产物）。
+             * 为什么这不算"偷偷写文件"：① 落点固定且**在我们自己的数据目录**里
+             * （`<DSH_HOME>/storages/sandore/output/<instanceId>/`，与 `sandore.sqlite` / 只读锁同一个家
+             * —— 不往用户的项目工作区写）；② 文件名由 step/attempt 派生 ⇒ **重复点击是覆盖，不是堆积**；
+             * ③ 写的是用户**刚刚点击**要看的那一段输出（不是后台产物）。
              */
             if (!canHandOff()) {
                 const failure = landingFailureOf();

package/lib/client/index.js

@@ -122,9 +122,9 @@ export async function apply(ctx) {
             sessions: sessionsCwdSource,
             // L1 的现取（`remote.session` 的漏斗 + 它的能力探针 `canOpenWorkspacePath`）。
             sessionRemote: () => sessionRemoteCtx?.get('remote.session'),
-            // Agent 输出落盘：host 唯一构造落点（`.sandore/artifacts/<instanceId>/…`），client 只拿回
-            // 真实绝对路径再交给 `openTab`。**它只在确认要交给 better-sidebar 时才写**
-            // （没 path 就没有 tab 的内容种子，见 `openOutput` 的结论注释）。
+            // Agent 输出落盘：host 唯一构造落点（`<DSH_HOME>/storages/sandore/output/<instanceId>/…`，
+            // **在会话 workspace 之外**），client 只拿回真实绝对路径再交给 `openTab`。**它只在确认要交给
+            // better-sidebar 时才写**（没 path 就没有 tab 的内容种子，见 `openOutput` 的结论注释）。
             // 显式给 `unwrap` 类型实参：`remoteCtx.remote.sandore` 的成员在客户端图里是 `any`
             // （cordis 注入 ctx 的 `remote` 面不参与类型收窄），而 `unwrap(any)` 会退化成
             // `unknown`（无法从 `any` 反推 T）⇒ 不开显式实参就取不到 `.path`。

package/lib/index.js

@@ -6,11 +6,11 @@ import { Service } from "@deepseek-ai/cordis";
 import z$1 from "@deepseek-ai/schemastery";
 import { SessionId, SessionSeq } from "@deepseek-ai/dsh-session";
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -5406,73 +5406,126 @@ function withMicroflow(definition, microflow, entryId, base) {
 //#endregion
 //#region packages/workflow/instance-output.ts
 /**
-* **Agent 输出落盘**（result 叶子 → 工作区内的真实文件）。
+* **Agent 输出落盘**（result 叶子 → 磁盘上的真实文件）。
 *
 * ## 为什么需要落盘
 * 工作流导航树里 **result 叶子（"Agent 输出"）只有文本、没有文件**（`run-view-model.ts`
-* 的 `buildRunTree` 从 `executedSteps[].output` 现算），而"打开文件"必须有文件。落点选择
-* 直接决定用户体验：
-*
-* - **落 workspace 内**（本模块）= 零配置：better-sidebar 的 `workspaceFence`（0.18.0 默认
-*   开启）只放行会话 cwd 之内的路径 ⇒ 打开即读得到内容；
-* - 落系统临时目录 = 用户每次都要去设置页手动关掉**全局** fence（并承担"任何同源脚本可越界
-*   读写"的代价），且**部署侧没有任何开关能预先关掉它**（`fenceEnabledOf` 只读 settings 服务，
-*   不吃插件 config）—— 故不采用。
+* 的 `buildRunTree` 从 `executedSteps[].output` 现算），而"打开文件"必须有文件。
 *
-* ## 落点（`<instanceId>/` 这一层**必需**）
+* ## 落点：**DSH home 下 sandore 自己的存储目录**（定稿，别再放回 workspace）
 * ```
-* <session cwd>/.sandore/artifacts/<instanceId>/<stepId>-<attemptIndex>-output.md
+* <DSH_HOME>/storages/sandore/output/<instanceId>/<stepId>-<attemptIndex>-output.md
 * ```
 * | 路径段 | 为什么必需 |
 * |---|---|
-* | `.sandore/artifacts/` | 单一隐藏目录，一条 gitignore（`.sandore/`）即可收敛 |
+* | `<DSH_HOME>/storages/sandore/` | 与 `storages/sandore.sqlite` / `storages/sandore-lock.json` **同一个家**：都是「sandore 自己的数据」，**不再往用户的项目工作区里写任何东西**（旧落点 `<实例 cwd>/.sandore/artifacts/` 会污染每个跑过工作流的仓库，还要用户自己加 `.gitignore`） |
+* | `output/` | 与其它 storage 子目录分开，便于整体清理（"Agent 输出"这一类可以一次性删空而不碰定义/锁） |
 * | **`<instanceId>/`** | `stepId` 是**定义内 id**：同一工作流跑多个实例时必然重名，没有实例维度会让多实例并发的同一 `stepId` 输出**互相覆盖**（`instanceId ≡ 宿主会话 id`，见 AGENTS.md 的实例身份恒等式） |
 * | `<stepId>-<attemptIndex>-output.md` | 同一实例内同一 step 的**多次执行段/重试**靠 `attemptIndex` 区分（与 `run-view-model.ts` 的段快照语义一致） |
 *
-* **不主动清理**：产出是用户的证据，删掉比留下更危险；清理权交给用户（文档写明落点与
-* 建议 gitignore）。
+* **不主动清理**：产出是用户的证据，删掉比留下更危险；清理权交给用户（清理面 =
+* `<DSH_HOME>/storages/sandore/output/` 整个目录）。
 *
-* 写盘走 **DSH 的 `ctx.fs` 服务**（本仓库 host 侧一律不直连 `node:fs`，与
-* `wakeup-diag.ts` 的纪律一致；`writeText` 已含父目录 `mkdir(recursive)`）。
+* ## 路径解析（绝不硬编码绝对路径）
+* 三级，与 `definition-lock.ts` 的 `resolveDefinitionLockPath` **同口径**：
+* ① 显式覆盖（测试 / 非常规部署）→ ② DSH 在 root ctx 上 `provide` 的
+* `dshHomePath('storages','sandore','output')` → ③ 本地回退（`$DSH_HOME`（trim 后非空）> `~/.dsh`）。
+* 第三级永不失败（总有一个字符串结果），**绝不返回 undefined/空串**（那会让落点退化成"写当前目录"
+* 这类意外位置）。
 *
-* ## 为什么必须**显式传 per-call 沙箱策略**（2026-09-20 真机报障的根因）
+* > ⚠️ 该回退与 `definition-lock.ts` 的 `fallbackDshHome` 是**同一套规则的两处实现**
+* > （两个模块都不依赖 `@deepseek-ai/dsh-home-paths`——本包 `node_modules` 里没有它）。
+* > 两边都有锁（`instance-output.spec.ts` / `definition-lock.spec.ts`），改规则要同时改。
 *
-* `ctx.fs` 若是**沙箱后端**（`@deepseek-ai/dsh-fs-sandbox` 的 `SandboxedFileSystem`），
-* 它的写盘判据是（`packages/fs/fs-sandbox/src/index.ts:122-142`）：
+* ## 写盘走 `ctx.fs`，但**必须显式给 per-call 沙箱策略**（P14 真机报障的根因）
+* `ctx.fs` 若是沙箱后端（`@deepseek-ai/dsh-fs-sandbox` 的 `SandboxedFileSystem`），它的写盘判据是
+* （`packages/fs/fs-sandbox/src/index.ts:122-142`）：
 * ```
-* const policy = sandboxPolicy ?? this.ctx.sandboxPolicy.resolve()   // ← 注意：不传就用**无会话**的兜底
+* const policy = sandboxPolicy ?? this.ctx.sandboxPolicy.resolve()   // ← 不传就用**无会话**的兜底
 * ```
-* 而无会话的 `resolve()`（`packages/sandbox/sandbox-policy/src/index.ts:163-170`）把
-* `workspaceRoot` 取成**部署兜底根**（`config.workspaceRoot ?? process.cwd()`），**不是**任何会话的
-* cwd；可写根集合 = `[workspaceRoot, '/tmp', tmpdir()]`（`packages/sandbox/sandbox/src/roots.ts:52-54`）。
-* ⇒ 只调 `fs.writeText(target, text)` 时，落点 `<实例 cwd>/.sandore/artifacts/…` 会被拿去与
-* **部署兜底根**比较，真机表现就是
-* `cannot write "D:\…\.sandore\artifacts\…-output.md": file access denied under workspace-write mode`
-* （`gateway/internal` 把这条内部错直接抛到了 UI）。
-*
-* 正解 = 复刻 DSH 自己的工具层做法（`packages/fs/tool-fs/src/sandbox.ts:87-92`）：
-* **每次写盘前解析"这个实例宿主会话"的策略并把第 5 个参数传给 `writeText`**，判据才是
-* 「该会话的 cwd」（`resolve({session})` ⇒ `session.header.cwd`）。见 {@link resolveWritePolicy}。
+* 而无会话的 `resolve()`（`packages/sandbox/sandbox-policy/src/index.ts:163-170`）把 `workspaceRoot`
+* 取成**部署兜底根**（`config.workspaceRoot ?? process.cwd()`）；`workspace-write` 的可写根集合 =
+* `[policy.workspaceRoot, '/tmp', tmpdir()]`（`packages/sandbox/sandbox/src/roots.ts:52-54`）。
+*
+* ⇒ 本批落点在 workspace **之外**，所以"解析出会话策略"还不够：还必须把**落点根**作为
+* `workspaceRoot` 交下去，否则 `workspace-write` 一定拒（真机形态正是
+* `cannot write "…": file access denied under workspace-write mode`）。见 {@link outputWritePolicy}。
+*
+* 三条纪律：
+* 1. **本模块自己拥有"落点根"**（{@link resolveOutputRoot}），**不向调用方要 cwd** —— 落点与
+*    实例 cwd 无关，要 cwd 只会让将来又漂回 workspace；
+* 2. 策略取不到（无沙箱后端的裸 `LocalFileSystem`）⇒ 第 5 参不传（后端本来就不判）；
+* 3. 被拒时由调用方折成 `INVALID_OPERATION` + 带**落点路径**的可见原因，
+*    **绝不把内部错原文抛给 UI**。
 * @module @meiyukichan/dsh-sandore/workflow/src/instance-output
 */
-/** Agent 输出落盘的固定目录段（相对会话 cwd）。 */
-const ARTIFACTS_DIR = ".sandore/artifacts";
+/** DSH home 目录名（`$DSH_HOME` 缺省时用它；与 DSH `home-paths` 的 `DSH_HOME_DIR_NAME` 同值）。 */
+const DSH_HOME_DIR_NAME$1 = ".dsh";
+/** 覆盖 DSH home 的环境变量名（与 DSH `home-paths` 的 `DSH_HOME_ENV` 同值）。 */
+const DSH_HOME_ENV$1 = "DSH_HOME";
+/** 落点在 DSH home 下的目录段（`<DSH_HOME>/storages/sandore/output`）。 */
+const OUTPUT_ROOT_SEGMENTS = [
+	"storages",
+	"sandore",
+	"output"
+];
+/** 非空（trim 后）才算数；空白串视为"没给"。 */
+function nonBlank$1(value) {
+	if (value === void 0) return void 0;
+	return value.trim().length === 0 ? void 0 : value;
+}
+/** `~` / `~/x` 展开成 home 下的路径。 */
+function expandHomePath$1(path) {
+	if (path === "~") return homedir();
+	if (path.startsWith("~/") || path.startsWith("~\\")) return join(homedir(), path.slice(2));
+	return path;
+}
 /**
-* **纯函数**：解析一次写盘应当使用的沙箱策略。
+* 本地回退解析 DSH home（`$DSH_HOME`（trim 后非空）> `<homeDir|os.homedir()>/.dsh`）。
+*
+* 与 `definition-lock.ts` 的 `fallbackDshHome` 同规则（那边有逐条出处注释）；生产路径上优先走
+* {@link OutputRootOptions.dshHomePath} 注入函数，那时**这套回退根本不参与**。
+* @param options - 解析入参。
+* @returns 归一化后的绝对 home 路径。
+*/
+function fallbackDshHome$1(options) {
+	const selected = nonBlank$1((options.env ?? process.env)[DSH_HOME_ENV$1]) ?? join(options.homeDir ?? homedir(), DSH_HOME_DIR_NAME$1);
+	return resolve(expandHomePath$1(selected));
+}
+/** 统一成 `/` 分隔（落点是**契约值**：调用方拿它拼 URL/展示，不随平台变）。 */
+function toSlashes(path) {
+	return path.replace(/\\/g, "/");
+}
+/**
+* **纯函数**：解析 Agent 输出的落点根（`<DSH_HOME>/storages/sandore/output`）。
+*
+* 三级优先级与 `resolveDefinitionLockPath` 同口径（见模块头）。**永不失败**：拿不到注入函数只是
+* 回退到本地规则，**绝不**返回 `undefined`/空串。
+* @param options - 解析入参；缺省 = 只剩本地回退。
+* @returns 落点根的绝对路径（统一 `/` 分隔；真正的绝对化由 `fs.resolve` 完成）。
+*/
+function resolveOutputRoot(options = {}) {
+	const explicit = nonBlank$1(options.explicitRoot);
+	if (explicit !== void 0) return toSlashes(explicit);
+	if (typeof options.dshHomePath === "function") return toSlashes(options.dshHomePath(...OUTPUT_ROOT_SEGMENTS));
+	return toSlashes(join(fallbackDshHome$1(options), ...OUTPUT_ROOT_SEGMENTS));
+}
+/**
+* **纯函数**：解析一次写盘"应当使用的会话策略"。
 *
 * 判据与 DSH 工具层逐字同源：`ctx.sandboxPolicy.resolve({ session })`，而 `session` 取
-* **该实例的宿主会话**（恒等式 `instanceId ≡ 宿主会话 id`）—— 产物写在它的工作目录里，
-* 判据就该是它的 cwd（`session.header.cwd`）。
+* **该实例的宿主会话**（恒等式 `instanceId ≡ 宿主会话 id`）——`mode` 由那个会话决定，
+* 它是**用户的意图**（read-only / workspace-write / danger-full-access），必须尊重。
 *
 * 三条"取不到就不假装知道"的纪律：
 * ① 部署没有沙箱后端（`sandboxPolicy` 缺席 = 裸 `LocalFileSystem`）⇒ `undefined`
 *    （第 5 参不传，后端本来就不判）；
 * ② 服务在但**会话取不到** ⇒ 也 `undefined`（不自己编一个 `workspaceRoot`：编错了就是
-*    "绕开用户的文件策略"，编窄了就是本次报障）；
+*    "绕开用户的文件策略"，编窄了就是 P14 报障）；
 * ③ `resolve()` 抛错（服务面畸形）⇒ `undefined`（由 `ctx.fs` 自己的兜底判据决定，绝不抛穿）。
 * @param deps - 两个服务（都可缺席）。
 * @param instanceId - 实例 id（≡ 宿主会话 id）。
-* @returns 该会话的沙箱策略；无法确定时 `undefined`。
+* @returns 该会话的策略；无法确定时 `undefined`。
 */
 function resolveWritePolicy(deps, instanceId) {
 	const service = deps.sandboxPolicy;
@@ -5486,6 +5539,32 @@ function resolveWritePolicy(deps, instanceId) {
 	}
 }
 /**
+* **纯函数**：把"会话策略"折成"这次写盘真正要用的策略"。
+*
+* 为什么需要它（落点搬到 workspace 之外后的**关键一步**）：`workspace-write` 的可写根是
+* **`policy.workspaceRoot`**，而会话策略的根是**会话 cwd**；落点
+* `<DSH_HOME>/storages/sandore/output/…` 永远在它之外 ⇒ 后端必然拒（`FS_SANDBOX_DENIED`）。
+* 而这次写盘的**委托人是应用本身**（把 Agent 输出落到 sandore 自己的数据目录），不是被沙箱约束的
+* 模型动作 ⇒ 该把**落点根**当作这次写盘的可写根。
+*
+* 逐档语义（**不对模式做任何放宽/收紧**）：
+* - `read-only` ⇒ **原样返回**（用户的"只读"意图包括"别在我机器上新增文件"，落盘照旧被拒）；
+* - `workspace-write` ⇒ 原模式 + `workspaceRoot` 换成**落点根**（只把可写面从"会话工作区"
+*   换成"我们自己的数据目录"，**不会**顺带放开工作区之外的任意路径）；
+* - `danger-full-access` ⇒ **原样返回**（后端本来就不判）；
+* - `undefined` ⇒ `undefined`（没有沙箱后端，本来就不判）。
+* @param policy - 会话策略（{@link resolveWritePolicy} 的结果）。
+* @param outputRoot - 落点根（{@link resolveOutputRoot} 的结果）。
+* @returns 这次写盘要传给 `writeText` 第 5 参的策略。
+*/
+function outputWritePolicy(policy, outputRoot) {
+	if (policy === void 0 || policy.mode !== "workspace-write") return policy;
+	return {
+		mode: "workspace-write",
+		workspaceRoot: outputRoot
+	};
+}
+/**
 * **纯函数**：这次失败是不是"沙箱拒绝写入"。
 *
 * 走 `code` 而不是 `instanceof FsError`：本模块**不依赖** `@deepseek-ai/dsh-fs`
@@ -5503,13 +5582,13 @@ function safeSegment(value) {
 	return cleaned === "" ? "step" : cleaned;
 }
 /**
-* **纯函数**：Agent 输出的落盘目录（`<cwd>/.sandore/artifacts/<instanceId>`）。
-* @param cwd - 会话工作目录。
+* **纯函数**：Agent 输出的落盘目录（`<落点根>/<instanceId>`）。
+* @param outputRoot - 落点根（{@link resolveOutputRoot}）。
 * @param instanceId - 实例 id（≡ 宿主会话 id）。
 * @returns 目录绝对路径（统一正斜杠；真正的绝对化由 `fs.resolve` 完成）。
 */
-function outputDirPath(cwd, instanceId) {
-	return `${cwd.replace(/\\/g, "/").replace(/\/+$/, "")}/${ARTIFACTS_DIR}/${safeSegment(instanceId)}`;
+function outputDirPath(outputRoot, instanceId) {
+	return `${outputRoot.replace(/\\/g, "/").replace(/\/+$/, "")}/${safeSegment(instanceId)}`;
 }
 /**
 * **纯函数**：Agent 输出的文件名。
@@ -5522,19 +5601,22 @@ function outputFileName(stepId, attemptIndex) {
 	return `${safeSegment(stepId)}-${attempt}-output.md`;
 }
 /**
-* 把一段文本落到实例的产物目录，返回**进程绝对路径**。
+* 把一段文本落到实例的输出目录，返回**进程绝对路径**。
 *
 * 幂等：同一 `(instanceId, stepId, attemptIndex)` 重复调用覆盖同一文件（输出是快照语义，
 * 不是追加日志）。
+*
+* **落点根由本函数自己解析**（{@link resolveOutputRoot}）：调用方**不需要也不该**传实例 cwd ——
+* 落点与工作区无关。
 * @param fs - host 的 `ctx.fs` 接缝。
-* @param cwd - 会话工作目录（`state.cwd`）。
 * @param input - `{instanceId, stepId, attemptIndex, text}`。
-* @param sandboxPolicy - **该实例宿主会话**的沙箱策略（{@link resolveWritePolicy}）；传了它
-*   `workspace-write` 的可写根才是那个会话的 cwd（不传 = 部署兜底根 ⇒ 真机报障）。
-* @returns 落点进程绝对路径（供 client 交给 better-sidebar 打开）。
+* @param sandboxPolicy - 这次写盘要用的策略（**已经过 {@link outputWritePolicy} 折算**的那个）；
+*   不传 ⇒ 沙箱后端按部署兜底根判（P14 报障形态）。
+* @param rootOptions - 落点根解析入参（测试 / 非常规部署；缺省 = 生产三级解析）。
+* @returns 落点进程绝对路径（供 client 交给 better-sidebar / 应用内卡片打开）。
 */
-async function writeInstanceOutput(fs, cwd, input, sandboxPolicy) {
-	const target = await fs.resolve(`${outputDirPath(cwd, input.instanceId)}/${outputFileName(input.stepId, input.attemptIndex)}`);
+async function writeInstanceOutput(fs, input, sandboxPolicy, rootOptions = {}) {
+	const target = await fs.resolve(`${outputDirPath(resolveOutputRoot(rootOptions), input.instanceId)}/${outputFileName(input.stepId, input.attemptIndex)}`);
 	await fs.writeText(target, input.text, void 0, void 0, sandboxPolicy);
 	return fs.processPath(target);
 }
@@ -5925,12 +6007,13 @@ const SendStepMessageInputSchema = z.object({
 	message: z.string().min(1)
 });
 /**
-* `writeInstanceOutputFile` 入参：把一段 **Agent 输出文本** 落到实例的产物目录。
+* `writeInstanceOutputFile` 入参：把一段 **Agent 输出文本** 落到实例的输出目录。
 *
 * 落点规则由 host 唯一构造（`instance-output.ts`）：
-* `<state.cwd>/.sandore/artifacts/<instanceId>/<stepId>-<attemptIndex>-output.md`。
-* `attemptIndex` 区分同一 step 的多次执行段/重试（0-based）；`<instanceId>/` 这一层
-* 防止多实例并发的同一 `stepId` 互相覆盖。`text` 上限 1 MiB（输出是快照，不是日志）。
+* `<DSH_HOME>/storages/sandore/output/<instanceId>/<stepId>-<attemptIndex>-output.md`
+* —— **与实例 cwd 无关**（不再往用户的工作区里写）。`attemptIndex` 区分同一 step 的多次执行段/
+* 重试（0-based）；`<instanceId>/` 这一层防止多实例并发的同一 `stepId` 互相覆盖。
+* `text` 上限 1 MiB（输出是快照，不是日志）。
 */
 const WriteInstanceOutputFileInputSchema = z.object({
 	instanceId: z.string(),
@@ -6794,44 +6877,46 @@ let SandoreRemote = (() => {
 			return await this.ctx.sandoreEngine.startInstance(request);
 		}
 		/**
-		* 把一段 **Agent 输出文本** 落到实例的产物目录，返回落点绝对路径（需求 7）。
+		* 把一段 **Agent 输出文本** 落到实例的输出目录，返回落点绝对路径（需求 7）。
 		*
 		* 为什么需要这条 RPC：工作流导航树里 **result 叶子（"Agent 输出"）只有文本、没有文件**，
-		* 而"点开文件"必须有文件；落点必须在**会话 workspace 内**（better-sidebar 的
-		* `workspaceFence` 默认开启，越界路径打开只会得到一张 fence 报错，而部署侧没有开关能预关它）。
+		* 而"点开文件"必须有文件。
 		*
 		* 落点（`<instanceId>/` 层**必需**：`stepId` 是定义内 id，多实例并发必然重名）：
-		* `<state.cwd>/.sandore/artifacts/<instanceId>/<stepId>-<attemptIndex>-output.md`。
-		* 写盘走 `ctx.fs`（本仓库 host 侧一律不直连 `node:fs`）；**不主动清理**（产出是用户的证据）。
+		* `<DSH_HOME>/storages/sandore/output/<instanceId>/<stepId>-<attemptIndex>-output.md`。
+		* 该根**与实例 cwd 无关**（`instance-output.ts` 自己按 DSH home 三级解析），所以这里**不读
+		* `state.cwd`**；写盘走 `ctx.fs`（本仓库 host 侧一律不直连 `node:fs`）；**不主动清理**
+		* （产出是用户的证据）。
 		*
 		* 快照优先取内存中的 live state（收尾中间态也能落），否则回退持久化快照；两者皆无抛
-		* `NODE_NOT_FOUND`。
+		* `NODE_NOT_FOUND`（取 state 只为**校验实例存在**，不再用于拼路径）。
 		*
-		* **沙箱纪律（2026-09-20 真机报障的修复）**：写盘必须带**该实例宿主会话**的
-		* per-call 沙箱策略（`resolveWritePolicy`）—— `ctx.fs` 的沙箱后端在不给策略时按
-		* **部署兜底根**（`config.workspaceRoot ?? process.cwd()`）判可写性，于是
-		* `<实例 cwd>/.sandore/artifacts/…` 会被判成"越界"并抛 `FS_SANDBOX_DENIED`
-		* （真机原文：`file access denied under workspace-write mode`）。拒绝时**不再把内部错
-		* 抛给 UI**：折成 `INVALID_OPERATION` + 带落点路径的可见原因（client 侧据此回退到
-		* 内存文本的应用内展示，见 `better-sidebar-open.ts` 的 `write-failed`）。
+		* **沙箱纪律（两步，P14 报障的完整修复）**：写盘必须带**该实例宿主会话**的 per-call 沙箱策略
+		* （`resolveWritePolicy`）—— `ctx.fs` 的沙箱后端在不给策略时按**部署兜底根**
+		* （`config.workspaceRoot ?? process.cwd()`）判可写性。**落点搬到 workspace 之外后还要第二步**：
+		* 用 `outputWritePolicy` 把策略的 `workspaceRoot` 折成**落点根**（`workspace-write` 的可写根就是
+		* `policy.workspaceRoot`，不折就一定越界）；`read-only` 原样保留 ⇒ 照旧被拒（用户的"只读"意图
+		* 包括"别在我机器上新增文件"）。被拒时**不再把内部错抛给 UI**：折成 `INVALID_OPERATION` +
+		* 带落点路径的可见原因（client 侧据此回退到内存文本的应用内展示，见 `better-sidebar-open.ts`
+		* 的 `write-failed`）。
 		*/
 		async writeInstanceOutputFile(input) {
 			const parsed = WriteInstanceOutputFileInputSchema.parse(input);
-			const live = this.ctx.sandoreEngine.getInstanceState(parsed.instanceId);
-			const state = live !== void 0 ? live : this.requireInstanceState(parsed.instanceId);
+			if (this.ctx.sandoreEngine.getInstanceState(parsed.instanceId) === void 0) this.requireInstanceState(parsed.instanceId);
 			const services = this.ctx;
+			const outputRoot = resolveOutputRoot({ ...typeof services.get("dshHomePath") === "function" ? { dshHomePath: services.get("dshHomePath") } : {} });
 			try {
-				return { path: await writeInstanceOutput(this.ctx.fs, state.cwd, {
+				return { path: await writeInstanceOutput(this.ctx.fs, {
 					instanceId: parsed.instanceId,
 					stepId: parsed.stepId,
 					attemptIndex: parsed.attemptIndex,
 					text: parsed.text
-				}, resolveWritePolicy({
+				}, outputWritePolicy(resolveWritePolicy({
 					sandboxPolicy: services.get("sandboxPolicy"),
 					sessions: services.get("sessions")
-				}, parsed.instanceId)) };
+				}, parsed.instanceId), outputRoot), { explicitRoot: outputRoot }) };
 			} catch (error) {
-				if (isSandboxDenial(error)) throw new SandoreError(`cannot write the step output into "${outputDirPath(state.cwd, parsed.instanceId)}": the file sandbox of this instance session denies that location`, "INVALID_OPERATION");
+				if (isSandboxDenial(error)) throw new SandoreError(`cannot write the step output into "${outputDirPath(outputRoot, parsed.instanceId)}": the file sandbox of this instance session denies that location`, "INVALID_OPERATION");
 				throw error;
 			}
 		}

package/lib/workflow/capability-registry.d.ts

@@ -172,13 +172,13 @@ export declare const INSTANCE_LIST_FRAGMENTS: {
     };
     status: ArgumentFragment & {
         readonly zod: z.ZodEnum<{
-            interacting: "interacting";
+            pending: "pending";
             running: "running";
+            interacting: "interacting";
             completed: "completed";
             failed: "failed";
-            paused: "paused";
-            pending: "pending";
             aborted: "aborted";
+            paused: "paused";
         }>;
     };
     limit: ArgumentFragment & {
@@ -221,8 +221,8 @@ export declare const SINGLE_TOOL_FRAGMENTS: {
         detail: ArgumentFragment & {
             readonly zod: z.ZodEnum<{
                 steps: "steps";
-                messages: "messages";
                 step: "step";
+                messages: "messages";
                 summary: "summary";
             }>;
         };
@@ -342,8 +342,8 @@ export declare const VisualizeArgsSchema: z.ZodObject<{
 export declare const StatusArgsSchema: z.ZodObject<{
     detail: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & z.ZodEnum<{
         steps: "steps";
-        messages: "messages";
         step: "step";
+        messages: "messages";
         summary: "summary";
     }>;
     instanceId: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & z.ZodString;

package/lib/workflow/domain.d.ts

@@ -18,14 +18,14 @@ export declare const sandoreDomainSpec: {
             taskId: string;
             workflowId: string;
             cwd: string;
-            status: "interacting" | "running" | "completed" | "failed" | "paused" | "pending" | "aborted";
+            status: "pending" | "running" | "interacting" | "completed" | "failed" | "aborted" | "paused";
             originalInput: string;
             currentStageId: string;
             executedSteps: {
                 id: string;
                 stageId: string;
                 name: string;
-                status: "blocked" | "ready" | "interacting" | "running" | "completed" | "failed" | "paused";
+                status: "running" | "interacting" | "completed" | "failed" | "paused" | "blocked" | "ready";
                 visitCount: number;
                 stepId?: string | undefined;
                 command?: {
@@ -78,7 +78,7 @@ export declare const sandoreDomainSpec: {
                 }[] | undefined;
                 sessionMeta?: {
                     synthetic: boolean;
-                    command: "agent" | "prompt" | "shell" | "skill" | "mcp";
+                    command: "shell" | "agent" | "prompt" | "skill" | "mcp";
                     childId?: string | undefined;
                     hostSessionId?: string | undefined;
                 } | undefined;
@@ -181,7 +181,7 @@ export declare const sandoreDomainSpec: {
                 error?: string | undefined;
                 pausedAt?: string | undefined;
                 sessionMessages?: {
-                    type: "text" | "reasoning" | "tool";
+                    type: "text" | "tool" | "reasoning";
                     text?: string | undefined;
                     tool?: string | undefined;
                     args?: unknown;
@@ -213,7 +213,7 @@ export declare const sandoreDomainSpec: {
             stageInfos: {
                 id: string;
                 name: string;
-                status: "blocked" | "ready" | "interacting" | "running" | "completed" | "failed" | "paused";
+                status: "running" | "interacting" | "completed" | "failed" | "paused" | "blocked" | "ready";
             }[];
             pendingInteractions: ({
                 id: string;
@@ -268,7 +268,7 @@ export declare const sandoreDomainSpec: {
             stageContracts: Record<string, {
                 stageId: string;
                 stageName: string;
-                status: "blocked" | "ready" | "interacting" | "running" | "completed" | "failed" | "paused";
+                status: "running" | "interacting" | "completed" | "failed" | "paused" | "blocked" | "ready";
                 artifacts: {
                     stepId: string;
                     outputToId: string;
@@ -298,7 +298,7 @@ export declare const sandoreDomainSpec: {
             permission?: string | undefined;
             userMessages?: {
                 id: string;
-                kind: "input" | "answer" | "resume" | "retry" | "message";
+                kind: "message" | "input" | "answer" | "resume" | "retry";
                 target: string;
                 content: string;
                 createdAt: string;