@oh-story/dsh 0.1.0 → 0.1.2

package/lib/index.js

@@ -216,8 +216,6 @@ function createDramaSkillProvider(skillRoot = defaultDramaSkillRoot()) {
 }
 
 // src/native-hooks.ts
-import { access, readdir as readdir2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep } from "node:path";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 var MUTATION_TOOLS = /* @__PURE__ */ new Set(["write", "edit", "str_replace_editor"]);
 function mutationPath(name2, args) {
@@ -229,52 +227,84 @@ function mutationPath(name2, args) {
   }
   return typeof record.file_path === "string" && record.file_path.trim() !== "" ? record.file_path : void 0;
 }
+function normalizedRelativePath(path) {
+  const segments = [];
+  for (const part of path.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      if (segments.length === 0) return void 0;
+      segments.pop();
+    } else segments.push(part);
+  }
+  return segments.join("/");
+}
 function detectStoryMutation(name2, args, cwd) {
-  const path = mutationPath(name2, args);
-  if (cwd === void 0 || path === void 0) return void 0;
-  const root = resolve2(cwd);
-  const absolute = isAbsolute2(path) ? resolve2(path) : resolve2(root, path);
-  const offset = relative2(root, absolute);
-  if (offset === ".." || offset.startsWith(`..${sep}`) || isAbsolute2(offset)) return void 0;
-  const normalized = offset.replaceAll("\\", "/");
+  const rawPath = mutationPath(name2, args);
+  if (cwd === void 0 || rawPath === void 0) return void 0;
+  const root = cwd.replaceAll("\\", "/").replace(/\/$/u, "");
+  const candidate = rawPath.replaceAll("\\", "/");
+  const absolute = candidate.startsWith("/") || /^[a-z]:\//iu.test(candidate) || /^[a-z][a-z\d+.-]*:\/\//iu.test(candidate);
+  const insideRoot = /^[a-z]:\//iu.test(root) ? candidate.toLowerCase().startsWith(`${root.toLowerCase()}/`) : candidate.startsWith(`${root}/`);
+  if (absolute && !insideRoot) return void 0;
+  const normalized = normalizedRelativePath(absolute ? candidate.slice(root.length + 1) : candidate);
+  if (normalized === void 0) return void 0;
   if (!normalized.startsWith("\u6B63\u6587/")) return void 0;
   const chapterText = /第0*(\d+)章/u.exec(normalized)?.[1];
   return { root, path: normalized, ...chapterText === void 0 ? {} : { chapter: Number(chapterText) } };
 }
-function storyMutation(exec) {
-  return detectStoryMutation(exec.name, exec.arguments, exec.agent?.session.header.cwd);
+async function storyMutation(exec, fs) {
+  const cwd = exec.agent?.session.header.cwd;
+  const path = mutationPath(exec.name, exec.arguments);
+  if (cwd === void 0 || path === void 0) return void 0;
+  try {
+    const [rootTarget, mutationTarget] = await Promise.all([
+      fs.resolve(cwd, { signal: exec.signal }),
+      fs.resolve(path, { cwd, signal: exec.signal })
+    ]);
+    if (!fs.contains(rootTarget, mutationTarget)) return void 0;
+  } catch {
+    return void 0;
+  }
+  return detectStoryMutation(exec.name, exec.arguments, cwd);
+}
+async function target(fs, root, path, signal) {
+  return fs.resolve(path, { cwd: root, ...signal === void 0 ? {} : { signal } });
 }
-async function exists(path) {
-  return access(path).then(() => true, () => false);
+async function exists(fs, root, path, signal) {
+  return target(fs, root, path, signal).then((value) => fs.stat(value, signal)).then((info) => info !== void 0, () => false);
 }
-async function hasChapterOutline(root, chapter) {
-  const entries = await readdir2(resolve2(root, "\u5927\u7EB2"), { withFileTypes: true }).catch(() => []);
-  return entries.some((entry) => entry.isFile() && Number(/^细纲_第0*(\d+)章.*\.md$/u.exec(entry.name)?.[1]) === chapter);
+async function hasChapterOutline(fs, root, chapter, signal) {
+  const entries = await target(fs, root, "\u5927\u7EB2", signal).then((directory) => fs.listDir(directory, signal)).catch(() => []);
+  return entries.some((entry) => entry.type === "file" && Number(/^细纲_第0*(\d+)章.*\.md$/u.exec(entry.name)?.[1]) === chapter);
 }
-async function validateStoryMutation(mutation) {
-  const hasLongFormLayout = await exists(resolve2(mutation.root, "\u5927\u7EB2")) || await exists(resolve2(mutation.root, "\u8FFD\u8E2A"));
+async function validateStoryMutation(fs, mutation, signal) {
+  const hasLongFormLayout = await exists(fs, mutation.root, "\u5927\u7EB2", signal) || await exists(fs, mutation.root, "\u8FFD\u8E2A", signal);
   if (!hasLongFormLayout) return void 0;
-  if (!await exists(resolve2(mutation.root, "\u8FFD\u8E2A/_tracking-state.json"))) {
+  if (!await exists(fs, mutation.root, "\u8FFD\u8E2A/_tracking-state.json", signal)) {
     return void 0;
   }
-  if (mutation.chapter !== void 0 && !await hasChapterOutline(mutation.root, mutation.chapter)) {
+  if (mutation.chapter !== void 0 && !await hasChapterOutline(fs, mutation.root, mutation.chapter, signal)) {
     return `Oh Story \u963B\u6B62\u5199\u5165\u7B2C ${String(mutation.chapter)} \u7AE0\uFF1A\u672A\u627E\u5230\u5BF9\u5E94\u7684 \u5927\u7EB2/\u7EC6\u7EB2_\u7B2CXXX\u7AE0*.md\u3002\u8BF7\u5148\u5B8C\u6210\u7EC6\u7EB2\u3002`;
   }
   return void 0;
 }
 async function decideStoryMutation(exec, next) {
-  const mutation = storyMutation(exec);
+  const fs = exec.agent?.ctx.get("fs");
+  if (fs === void 0) return next();
+  const mutation = await storyMutation(exec, fs);
   if (mutation === void 0) return next();
-  const reason = await validateStoryMutation(mutation);
+  const reason = await validateStoryMutation(fs, mutation, exec.signal);
   if (reason !== void 0) return { kind: "deny", reason };
   return next();
 }
 function registerOhStoryHooks(context) {
   context.on("tools/pre-execute", decideStoryMutation);
   context.on("tools/post-execute", async (exec, result, next) => {
-    const mutation = storyMutation(exec);
     const downstream = await next();
-    if (mutation === void 0 || result.isError || downstream.kind !== "accept") return downstream;
+    if (result.isError || downstream.kind !== "accept") return downstream;
+    const fs = exec.agent?.ctx.get("fs");
+    const mutation = fs === void 0 ? void 0 : await storyMutation(exec, fs);
+    if (mutation === void 0) return downstream;
     const reminder = createUserMessage({
       source: { kind: "plugin", plugin: "oh-story" },
       content: [{
@@ -294,7 +324,7 @@ import { defineTool } from "@deepseek-ai/dsh-tools";
 
 // src/role-provider.ts
 import { readFile as readFile2 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname2, join as join2, resolve as resolve3 } from "node:path";
+import { basename as basename2, dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var OH_STORY_ROLE_NAMES = [
   "chapter-extractor",
@@ -311,10 +341,10 @@ function roleBody(source) {
 }
 function defaultBundledRoleRoot() {
   const current = dirname2(fileURLToPath2(import.meta.url));
-  return basename2(current) === "src" ? resolve3(current, "../../knowledge/oh-story/roles") : resolve3(current, "oh-story/roles");
+  return basename2(current) === "src" ? resolve2(current, "../../knowledge/oh-story/roles") : resolve2(current, "oh-story/roles");
 }
 async function loadBundledRole(name2, roleRoot = defaultBundledRoleRoot(), execution = "tool-free") {
-  const body = roleBody(await readFile2(join2(resolve3(roleRoot), `${name2}.md`), "utf8"));
+  const body = roleBody(await readFile2(join2(resolve2(roleRoot), `${name2}.md`), "utf8"));
   if (body.length === 0) throw new Error(`Bundled role "${name2}" is empty.`);
   const integration = execution === "tool-free" ? [
     "You are running inside an Oh Story review-required DSH collaboration. The caller supplies every permitted input in the prompt.",
@@ -337,12 +367,12 @@ async function loadBundledRole(name2, roleRoot = defaultBundledRoleRoot(), execu
 var OH_STORY_ROLE_TOOL_NAME = "oh_story_role";
 var roleTools = {
   "chapter-extractor": ["read", "glob", "grep"],
-  "character-designer": ["read", "glob", "grep"],
+  "character-designer": ["read", "glob", "grep", "write", "edit"],
   "consistency-checker": ["read", "glob", "grep"],
-  "narrative-writer": ["read", "glob", "grep", "bash"],
-  "story-architect": ["read", "glob", "grep"],
+  "narrative-writer": ["read", "glob", "grep", "write", "edit", "bash"],
+  "story-architect": ["read", "glob", "grep", "write", "edit"],
   "story-explorer": ["read", "glob", "grep"],
-  "story-researcher": ["read", "glob", "grep", "bash", "web_search", "web_fetch"]
+  "story-researcher": ["read", "glob", "grep", "bash", "write", "web_search", "web_fetch"]
 };
 function roleToolFilter(role) {
   return { allow: roleTools[role] };
@@ -434,68 +464,10 @@ async function registerOhStoryRoleTool(context) {
 }
 
 // src/workspace-route.ts
-import { createHash, randomUUID } from "node:crypto";
-import { mkdir, readFile as readFile3, readdir as readdir3, rename, rm, stat, writeFile } from "node:fs/promises";
-import { dirname as dirname3, extname, join as join3, relative as relative4, resolve as resolve5 } from "node:path";
+import { extname } from "node:path";
+import { FsError } from "@deepseek-ai/dsh-fs";
 import { SessionId } from "@deepseek-ai/dsh-session";
 
-// src/workspace-security.ts
-import { lstat, realpath } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve4, sep as sep2 } from "node:path";
-var PathSecurityError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "PathSecurityError";
-  }
-};
-function isInside(root, candidate) {
-  const offset = relative3(root, candidate);
-  return offset === "" || !offset.startsWith(`..${sep2}`) && offset !== ".." && !isAbsolute3(offset);
-}
-async function canonicalWorkspaceRoot(root) {
-  const canonical = await realpath(root);
-  const info = await lstat(canonical);
-  if (!info.isDirectory()) throw new PathSecurityError("Workspace root must be a directory.");
-  return canonical;
-}
-async function resolveWorkspacePath(root, relativePath, options = {}) {
-  if (relativePath.includes("\0") || isAbsolute3(relativePath) || /^[A-Za-z]:[\\/]/u.test(relativePath)) {
-    throw new PathSecurityError("Only workspace-relative paths are allowed.");
-  }
-  const segments = relativePath.replaceAll("\\", "/").split("/");
-  if (segments.some((segment) => segment === ".." || segment === "")) {
-    throw new PathSecurityError("Path traversal and empty segments are not allowed.");
-  }
-  const canonicalRoot = await canonicalWorkspaceRoot(root);
-  const candidate = resolve4(canonicalRoot, ...segments);
-  if (!isInside(canonicalRoot, candidate)) throw new PathSecurityError("Path escapes the workspace.");
-  let cursor = canonicalRoot;
-  for (let index = 0; index < segments.length; index += 1) {
-    cursor = resolve4(cursor, segments[index] ?? "");
-    try {
-      const info = await lstat(cursor);
-      if (info.isSymbolicLink()) {
-        const target = await realpath(cursor);
-        if (!isInside(canonicalRoot, target)) throw new PathSecurityError("Symbolic link escapes the workspace.");
-        cursor = target;
-      }
-      if (index < segments.length - 1 && !info.isDirectory()) throw new PathSecurityError("A path parent is not a directory.");
-      if (index === segments.length - 1 && options.expect !== void 0) {
-        if (options.expect === "file" && !info.isFile()) throw new PathSecurityError("Expected a regular file.");
-        if (options.expect === "directory" && !info.isDirectory()) throw new PathSecurityError("Expected a directory.");
-      }
-    } catch (error) {
-      if (error instanceof PathSecurityError) throw error;
-      const code = error instanceof Error && "code" in error ? String(error.code) : "";
-      if (code === "ENOENT" && options.allowMissing === true && index === segments.length - 1) return cursor;
-      throw error;
-    }
-  }
-  const finalPath = await realpath(cursor);
-  if (!isInside(canonicalRoot, finalPath)) throw new PathSecurityError("Resolved path escapes the workspace.");
-  return finalPath;
-}
-
 // src/workspace-request-trust.ts
 function header(headers, name2) {
   if (headers instanceof Headers) return headers.get(name2) ?? void 0;
@@ -552,6 +524,7 @@ var DRAMA_DIRECTORIES = ["\u8F93\u5165", "\u9879\u76EE\u5F00\u53D1", "\u8BBE\u5B
 var CREATIVE_DIRECTORIES = [...STORY_DIRECTORIES, ...DRAMA_DIRECTORIES];
 var ROOT_FILES = /* @__PURE__ */ new Set(["short-drama.json"]);
 var EDITABLE_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".json", ".jsonl"]);
+var FILE_LIMIT = 1e3;
 var WorkspaceHttpError = class extends Error {
   constructor(status, message) {
     super(message);
@@ -570,9 +543,6 @@ function send(response, status, value) {
   });
   response.end(body);
 }
-function workspaceContentVersion(content) {
-  return createHash("sha256").update(content).digest("hex");
-}
 async function jsonBody(request, maxBytes) {
   const chunks = [];
   let size = 0;
@@ -594,7 +564,7 @@ function assertCreativePath(path) {
   if (!EDITABLE_EXTENSIONS.has(extname(path).toLocaleLowerCase())) {
     throw new WorkspaceHttpError(415, "\u5DE5\u4F5C\u53F0\u53EA\u7F16\u8F91 Markdown\u3001\u6587\u672C\u3001JSON \u548C JSONL \u6587\u4EF6\u3002");
   }
-  if (path.split("/").some((segment) => segment === "" || segment === "..")) {
+  if (path.startsWith("/") || path.includes("\\") || path.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
     throw new WorkspaceHttpError(403, "\u6587\u4EF6\u8DEF\u5F84\u4E0D\u5728\u521B\u4F5C\u5DE5\u4F5C\u53F0\u4E2D\u3002");
   }
   const root = path.split("/", 1)[0];
@@ -602,112 +572,160 @@ function assertCreativePath(path) {
     throw new WorkspaceHttpError(403, "\u6587\u4EF6\u8DEF\u5F84\u4E0D\u5728\u521B\u4F5C\u5DE5\u4F5C\u53F0\u4E2D\u3002");
   }
 }
-async function listFiles(root) {
+async function workspaceRealm(context, url) {
+  const rawId = url.searchParams.get("sessionId");
+  if (rawId === null || rawId === "") throw new WorkspaceHttpError(400, "\u7F3A\u5C11 DSH sessionId\u3002");
+  const lookup = context.typert.lookups.get("agent");
+  if (lookup === void 0) throw new WorkspaceHttpError(503, "DSH Agent lookup \u5F53\u524D\u4E0D\u53EF\u7528\u3002");
+  let agent;
+  try {
+    agent = await lookup.resolve(SessionId(rawId));
+  } catch {
+    throw new WorkspaceHttpError(404, "DSH \u4F1A\u8BDD\u4E0D\u53EF\u7528\u3002");
+  }
+  if (agent === void 0) throw new WorkspaceHttpError(404, "DSH \u4F1A\u8BDD\u4E0D\u53EF\u7528\u3002");
+  if (agent.session.header.parentSession !== void 0 || agent.session.header.origin === "subagent") {
+    throw new WorkspaceHttpError(403, "\u5B50 Agent \u4F1A\u8BDD\u4E0D\u5F00\u653E\u521B\u4F5C\u7F16\u8F91\u5668\u3002");
+  }
+  const cwd = agent.session.header.cwd;
+  if (cwd === void 0) throw new WorkspaceHttpError(409, "\u5F53\u524D DSH \u4F1A\u8BDD\u6CA1\u6709\u5DE5\u4F5C\u76EE\u5F55\u3002");
+  const fs = agent.ctx.get("fs");
+  const sandboxPolicy = agent.ctx.get("sandboxPolicy");
+  if (fs === void 0 || sandboxPolicy === void 0) throw new WorkspaceHttpError(503, "DSH \u6587\u4EF6\u7CFB\u7EDF\u5F53\u524D\u4E0D\u53EF\u7528\u3002");
+  return { agent, fs, sandboxPolicy, cwd, root: await fs.resolve(cwd) };
+}
+async function creativeTarget(realm, path) {
+  assertCreativePath(path);
+  const target2 = await realm.fs.resolve(path, { cwd: realm.cwd });
+  if (!realm.fs.contains(realm.root, target2)) throw new WorkspaceHttpError(403, "\u6587\u4EF6\u8DEF\u5F84\u79BB\u5F00\u4E86 DSH \u5DE5\u4F5C\u76EE\u5F55\u3002");
+  return target2;
+}
+function requireRegularFile(info) {
+  if (info === void 0) throw new WorkspaceHttpError(404, "\u6587\u4EF6\u4E0D\u5B58\u5728\u3002");
+  if (info.type !== "file") throw new WorkspaceHttpError(415, "\u76EE\u6807\u4E0D\u662F\u53EF\u7F16\u8F91\u7684\u666E\u901A\u6587\u4EF6\u3002");
+  return info;
+}
+async function readVersionedFile(fs, target2, maxBytes) {
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const before = requireRegularFile(await fs.stat(target2));
+    if (before.size !== void 0 && before.size > maxBytes) throw new WorkspaceHttpError(413, "\u6587\u4EF6\u8D85\u8FC7\u5DE5\u4F5C\u53F0\u5927\u5C0F\u9650\u5236\u3002");
+    const bytes = await fs.readBytes(target2, void 0, maxBytes);
+    const after = requireRegularFile(await fs.stat(target2));
+    if (before.version !== after.version) continue;
+    let content;
+    try {
+      content = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    } catch {
+      throw new WorkspaceHttpError(415, "\u6587\u4EF6\u4E0D\u662F\u6709\u6548\u7684 UTF-8 \u6587\u672C\u3002");
+    }
+    return { content, bytes: bytes.byteLength, version: after.version };
+  }
+  throw new WorkspaceHttpError(409, "\u6587\u4EF6\u6B63\u5728\u88AB\u4FEE\u6539\uFF0C\u8BF7\u91CD\u8BD5\u3002");
+}
+async function listFiles(realm) {
   const files = [];
-  const walk = async (directory) => {
-    const absolute = await resolveWorkspacePath(root, directory, { expect: "directory" });
-    for (const entry of await readdir3(absolute, { withFileTypes: true })) {
-      if (entry.isSymbolicLink() || entry.name.startsWith(".")) continue;
-      const path = `${directory}/${entry.name}`;
-      if (entry.isDirectory()) await walk(path);
-      else if (entry.isFile() && EDITABLE_EXTENSIONS.has(extname(entry.name).toLocaleLowerCase())) {
-        files.push({ path, bytes: (await stat(join3(absolute, entry.name))).size });
+  const walk = async (path, directory) => {
+    for (const entry of await realm.fs.listDir(directory)) {
+      if (entry.name.startsWith(".") || !realm.fs.contains(realm.root, entry.target)) continue;
+      const childPath = `${path}/${entry.name}`;
+      if (entry.type === "directory") await walk(childPath, entry.target);
+      else if (entry.type === "file" && EDITABLE_EXTENSIONS.has(extname(entry.name).toLocaleLowerCase())) {
+        const info = entry.version === void 0 || entry.size === void 0 ? await realm.fs.stat(entry.target) : void 0;
+        const version = entry.version ?? info?.version;
+        if (version !== void 0) files.push({ path: childPath, bytes: entry.size ?? info?.size ?? 0, version });
       }
-      if (files.length >= 1e3) return;
+      if (files.length >= FILE_LIMIT) return;
     }
   };
-  for (const directory of CREATIVE_DIRECTORIES) await walk(directory).catch(() => void 0);
+  for (const directory of CREATIVE_DIRECTORIES) {
+    const target2 = await realm.fs.resolve(directory, { cwd: realm.cwd });
+    if (!realm.fs.contains(realm.root, target2)) continue;
+    const info = await realm.fs.stat(target2);
+    if (info?.type === "directory") await walk(directory, target2);
+    if (files.length >= FILE_LIMIT) break;
+  }
   for (const path of ROOT_FILES) {
-    await resolveWorkspacePath(root, path, { expect: "file" }).then(async (absolute) => {
-      files.push({ path, bytes: (await stat(absolute)).size });
-    }).catch(() => void 0);
+    const target2 = await creativeTarget(realm, path);
+    const info = await realm.fs.stat(target2);
+    if (info?.type === "file") files.push({ path, bytes: info.size ?? 0, version: info.version });
   }
   return files.sort((left, right) => left.path.localeCompare(right.path, "zh-Hans-CN"));
 }
-function sessionRoot(context, url) {
-  const id = url.searchParams.get("sessionId");
-  if (id === null || id === "") throw new WorkspaceHttpError(400, "\u7F3A\u5C11 DSH sessionId\u3002");
-  const session = context.sessions.get(SessionId(id));
-  if (session === void 0) throw new WorkspaceHttpError(404, "DSH \u4F1A\u8BDD\u4E0D\u53EF\u7528\u3002");
-  if (session.header.parentSession !== void 0) throw new WorkspaceHttpError(403, "\u5B50 Agent \u4F1A\u8BDD\u4E0D\u5F00\u653E\u5C0F\u8BF4\u7F16\u8F91\u5668\u3002");
-  const cwd = session.header.cwd;
-  if (cwd === void 0) throw new WorkspaceHttpError(409, "\u5F53\u524D DSH \u4F1A\u8BDD\u6CA1\u6709\u5DE5\u4F5C\u76EE\u5F55\u3002");
-  return canonicalWorkspaceRoot(cwd);
+async function metadata(realm, files, path, maxBytes) {
+  if (!files.some((file) => file.path === path)) return { value: null };
+  try {
+    const target2 = await creativeTarget(realm, path);
+    return { value: JSON.parse((await readVersionedFile(realm.fs, target2, maxBytes)).content) };
+  } catch (error) {
+    return { value: null, error: error instanceof SyntaxError ? `${path} \u4E0D\u662F\u6709\u6548\u7684 JSON\u3002` : `${path} \u6682\u65F6\u65E0\u6CD5\u8BFB\u53D6\u3002` };
+  }
+}
+function mapFsError(error) {
+  if (!(error instanceof FsError)) return void 0;
+  switch (error.code) {
+    case "FS_NOT_FOUND":
+      return new WorkspaceHttpError(404, "\u6587\u4EF6\u4E0D\u5B58\u5728\u3002");
+    case "FS_TOO_LARGE":
+      return new WorkspaceHttpError(413, "\u6587\u4EF6\u8D85\u8FC7\u5DE5\u4F5C\u53F0\u5927\u5C0F\u9650\u5236\u3002");
+    case "FS_NOT_TEXT":
+    case "FS_NOT_REGULAR_FILE":
+      return new WorkspaceHttpError(415, "\u76EE\u6807\u4E0D\u662F\u53EF\u7F16\u8F91\u7684\u6587\u672C\u6587\u4EF6\u3002");
+    case "FS_PERMISSION_DENIED":
+    case "FS_SANDBOX_DENIED":
+      return new WorkspaceHttpError(403, "\u5F53\u524D DSH \u6743\u9650\u4E0D\u5141\u8BB8\u4FEE\u6539\u8BE5\u6587\u4EF6\u3002");
+    case "FS_STALE_VERSION":
+    case "FS_NOT_OBSERVED":
+      return new WorkspaceHttpError(412, "\u6587\u4EF6\u5DF2\u5728\u78C1\u76D8\u4E0A\u66F4\u65B0\u3002\u8BF7\u5904\u7406\u51B2\u7A81\u540E\u518D\u4FDD\u5B58\u3002");
+    case "FS_ABORTED":
+      return new WorkspaceHttpError(409, "\u6587\u4EF6\u64CD\u4F5C\u5DF2\u53D6\u6D88\u3002");
+    default:
+      return new WorkspaceHttpError(500, "DSH \u6587\u4EF6\u7CFB\u7EDF\u64CD\u4F5C\u5931\u8D25\u3002");
+  }
 }
 async function handle(context, request, response, options) {
   try {
-    if (!isTrustedWorkspaceRequest(request, options.trustedHosts ?? [])) {
-      throw new WorkspaceHttpError(403, "\u8BF7\u6C42\u6765\u6E90\u4E0D\u53D7\u4FE1\u4EFB\u3002");
-    }
+    if (!isTrustedWorkspaceRequest(request, options.trustedHosts ?? [])) throw new WorkspaceHttpError(403, "\u8BF7\u6C42\u6765\u6E90\u4E0D\u53D7\u4FE1\u4EFB\u3002");
     const url = new URL(request.url ?? "/", "http://127.0.0.1");
     if (url.pathname === "/oh-story/workspace" && request.method === "GET") {
-      const root = await sessionRoot(context, url);
-      const files = await listFiles(root);
-      const trackingFile = files.find((file) => file.path === "\u8FFD\u8E2A/_tracking-state.json");
-      const tracking = trackingFile === void 0 ? null : JSON.parse(await readFile3(await resolveWorkspacePath(root, trackingFile.path, { expect: "file" }), "utf8"));
-      const dramaFile = files.find((file) => file.path === "short-drama.json");
-      const shortDrama = dramaFile === void 0 ? null : JSON.parse(await readFile3(await resolveWorkspacePath(root, dramaFile.path, { expect: "file" }), "utf8"));
-      send(response, 200, { cwd: root, files, tracking, shortDrama, mode: "dsh-session" });
+      const realm = await workspaceRealm(context, url);
+      const files = await listFiles(realm);
+      const tracking = await metadata(realm, files, "\u8FFD\u8E2A/_tracking-state.json", options.maxBytes);
+      const shortDrama = await metadata(realm, files, "short-drama.json", options.maxBytes);
+      const metadataErrors = [tracking.error, shortDrama.error].filter((value) => value !== void 0);
+      send(response, 200, { cwd: realm.cwd, files, tracking: tracking.value, shortDrama: shortDrama.value, metadataErrors, mode: "dsh-session" });
       return;
     }
     if (url.pathname === "/oh-story/file" && request.method === "GET") {
-      const root = await sessionRoot(context, url);
+      const realm = await workspaceRealm(context, url);
       const path = url.searchParams.get("path");
       if (path === null) throw new WorkspaceHttpError(400, "\u7F3A\u5C11\u6587\u4EF6\u8DEF\u5F84\u3002");
-      assertCreativePath(path);
-      const absolute = await resolveWorkspacePath(root, path, { expect: "file" });
-      const data = await readFile3(absolute);
-      if (data.byteLength > options.maxBytes) throw new WorkspaceHttpError(413, "\u6587\u4EF6\u8D85\u8FC7\u5DE5\u4F5C\u53F0\u5927\u5C0F\u9650\u5236\u3002");
-      send(response, 200, {
-        path,
-        content: data.toString("utf8"),
-        bytes: data.byteLength,
-        version: workspaceContentVersion(data)
-      });
+      const file = await readVersionedFile(realm.fs, await creativeTarget(realm, path), options.maxBytes);
+      send(response, 200, { path, ...file });
       return;
     }
     if (url.pathname === "/oh-story/file" && request.method === "PUT") {
-      const root = await sessionRoot(context, url);
+      const realm = await workspaceRealm(context, url);
       const path = url.searchParams.get("path");
       if (path === null) throw new WorkspaceHttpError(400, "\u7F3A\u5C11\u6587\u4EF6\u8DEF\u5F84\u3002");
-      assertCreativePath(path);
       const input = await jsonBody(request, options.maxBytes * 6 + 1024);
       if (typeof input.content !== "string") throw new WorkspaceHttpError(400, "content \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u3002");
-      if (typeof input.baseVersion !== "string") throw new WorkspaceHttpError(400, "baseVersion \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u3002");
+      if (typeof input.baseVersion !== "string" || input.baseVersion === "") throw new WorkspaceHttpError(400, "baseVersion \u5FC5\u987B\u662F\u6709\u6548\u7248\u672C\u3002");
       if (Buffer.byteLength(input.content) > options.maxBytes) throw new WorkspaceHttpError(413, "\u6587\u4EF6\u8D85\u8FC7\u5DE5\u4F5C\u53F0\u5927\u5C0F\u9650\u5236\u3002");
-      const absolute = await resolveWorkspacePath(root, path, { expect: "file" });
-      const current = await readFile3(absolute);
-      if (workspaceContentVersion(current) !== input.baseVersion) {
-        throw new WorkspaceHttpError(412, "\u6587\u4EF6\u5DF2\u5728\u78C1\u76D8\u4E0A\u66F4\u65B0\u3002\u8BF7\u5237\u65B0\u5E76\u5408\u5E76\u540E\u518D\u4FDD\u5B58\u3002");
-      }
-      const parent = dirname3(absolute);
-      await mkdir(parent, { recursive: true });
-      const rootReal = await canonicalWorkspaceRoot(root);
-      const parentReal = await canonicalWorkspaceRoot(parent);
-      const offset = relative4(rootReal, parentReal);
-      if (offset === ".." || offset.startsWith("../")) throw new WorkspaceHttpError(403, "\u6587\u4EF6\u8DEF\u5F84\u79BB\u5F00\u4E86 DSH \u5DE5\u4F5C\u76EE\u5F55\u3002");
-      const temporary = resolve5(parent, `.${randomUUID()}.oh-story.tmp`);
-      try {
-        await writeFile(temporary, input.content, { encoding: "utf8", flag: "wx" });
-        if (workspaceContentVersion(await readFile3(absolute)) !== input.baseVersion) {
-          throw new WorkspaceHttpError(412, "\u6587\u4EF6\u5DF2\u5728\u78C1\u76D8\u4E0A\u66F4\u65B0\u3002\u8BF7\u5237\u65B0\u5E76\u5408\u5E76\u540E\u518D\u4FDD\u5B58\u3002");
-        }
-        await rename(temporary, absolute);
-      } finally {
-        await rm(temporary, { force: true });
-      }
-      send(response, 200, {
-        path,
-        content: input.content,
-        bytes: Buffer.byteLength(input.content),
-        version: workspaceContentVersion(input.content)
-      });
+      const outcome = await realm.fs.writeText(
+        await creativeTarget(realm, path),
+        input.content,
+        { kind: "replaceIfVersion", version: input.baseVersion },
+        void 0,
+        realm.sandboxPolicy.resolve({ session: realm.agent.session })
+      );
+      send(response, 200, { path, content: outcome.after, bytes: Buffer.byteLength(outcome.after), version: outcome.version });
       return;
     }
     send(response, 404, { error: "Oh Story route not found." });
   } catch (error) {
-    if (error instanceof WorkspaceHttpError) send(response, error.status, { error: error.message });
-    else send(response, 500, { error: error instanceof Error ? error.message : String(error) });
+    const mapped = error instanceof WorkspaceHttpError ? error : mapFsError(error);
+    if (mapped === void 0) context.logger("oh-story").error("workspace route failed", error);
+    send(response, mapped?.status ?? 500, { error: mapped?.message ?? "Oh Story workspace operation failed." });
   }
 }
 function registerWorkspaceRoute(context, options) {
@@ -720,7 +738,7 @@ function registerWorkspaceRoute(context, options) {
 
 // src/index.ts
 var name = "oh-story";
-var inject = ["sessions", "skills", "subagents", "tools", "webServer"];
+var inject = ["skills", "subagents", "tools", "typert", "webServer"];
 var Config = z.object({
   editorMaxBytes: z.natural().min(65536).max(8388608).default(2097152),
   trustedHosts: z.array(String).default([])