@oh-story/dsh 0.1.3 → 0.1.5

package/lib/index.js

@@ -10,24 +10,25 @@ import {
 } from "@deepseek-ai/dsh-skill";
 var STORY_PROVIDER_NAME = "oh-story";
 var DRAMA_PROVIDER_NAME = "short-drama";
-var INVOCATION = { modelInvocable: true, userInvocable: true };
+var GAME_PROVIDER_NAME = "novel-to-game";
+var VIDEO_PROVIDER_NAME = "video-recap";
 var DSH_SKILL_BRIDGE = [
   "<oh-story-dsh-integration>",
   "This Skill is a native contribution to the current DeepSeek Harness session.",
   "DSH owns the workspace, model, preset, permissions, Session Log, tools, subagents, cancellation, resume, and Agent UI.",
   "Never start another Agent runtime, session transport, Dashboard, SSE stream, polling loop, or model configuration.",
   "All seven upstream Oh Story specialist Roles are bundled. Invoke one with oh_story_role and a self-contained prompt.",
-  "Never inspect .claude/agents, .codex/agents, .opencode/agents, or .story-deployed to decide whether a Role is available.",
+  "Never inspect .claude/agents, .codex/agents, .opencode/agents, .agents/agents, .zcode, or .story-deployed to decide whether a Role is available, and never call invoke_subagent with a TypeName.",
   "Use only DSH-visible tools. DSH sandbox and permission policy remain authoritative.",
   "</oh-story-dsh-integration>"
 ].join("\n");
 var DSH_SKILL_OVERRIDES = {
   story: "The \u5C0F\u8BF4 workspace is an official DSH conversation view. Never start or open a second web application.",
-  "story-setup": "Initialize or validate novel project data only. DSH already supplies Skills, Roles, hooks, tools, permissions, sessions, and UI; never deploy Claude/OpenCode/Codex/ZCode/OpenClaw/Reasonix files or a .story-deployed marker.",
+  "story-setup": "Initialize or validate novel project data only. DSH already supplies Skills, Roles, hooks, tools, permissions, sessions, and UI; never deploy Claude/OpenCode/Codex/Antigravity/ZCode/OpenClaw/Reasonix files or a .story-deployed marker.",
   "story-long-analyze": "Use oh_story_role for chapter extraction or specialist analysis. Never inspect platform agent directories or require a deployed external Agent definition.",
   "story-long-write": "All named Roles are provided through oh_story_role. Do not check platform agent files. Keep the upstream writing, Tracking, lint, outline, revision, and quality workflows.",
   "story-review": "All named reviewer Roles are provided through oh_story_role. Do not check platform agent files; full/lean review may use the bundled Roles directly.",
-  "story-import": "All named Roles are provided through oh_story_role. Do not require story-setup to deploy them.",
+  "story-import": "All named Roles are provided through oh_story_role. Do not require story-setup to deploy them, and never inspect platform agent directories.",
   "story-deslop": "Use the bundled narrative-writer Role through oh_story_role when specialist review is useful. Never inspect platform agent directories.",
   "story-short-analyze": "Use oh_story_role for specialist analysis. Never inspect platform agent directories or require external Agent deployment.",
   "story-short-write": "All named Roles are provided through oh_story_role. Do not inspect platform agent files; preserve the upstream short-fiction workflow and quality gates.",
@@ -39,14 +40,42 @@ var DSH_DRAMA_BRIDGE = [
   "This Skill is a native contribution to the current DeepSeek Harness session.",
   "DSH owns the workspace, model, preset, permissions, Session Log, tools, approvals, cancellation, resume, and Agent UI.",
   "The \u77ED\u5267 tab is the creator workspace. Never start dashboard_server.py, another web server, Dashboard, Agent runtime, session transport, or model configuration.",
+  "Drama Skills v0.6 uses a creator-first contract: each episode keeps only the requested documents, up to five creator-facing sources at \u5267\u96C6/<EP>/\u5267\u672C.md, \u89C6\u89C9\u8BBE\u5B9A.md, \u5206\u955C.md, \u56FE\u7247\u63D0\u793A\u8BCD.md, and \u89C6\u9891\u63D0\u793A\u8BCD.md. Never precreate empty documents, backfill nominal stages, or start work the creator did not request. Persisted reviews use creator-readable Markdown under \u5BA1\u67E5/; an oral review writes nothing.",
+  "For a v0.6 project, never create a parallel JSON/JSONL lifecycle truth, indexes, fingerprints, coverage tables, or QA records merely because legacy maintenance scripts and templates remain bundled.",
+  "Never upgrade a v0.5 structured project in place or mix both contracts in one project root. Keep legacy production/audit artifacts read-only and pinned to v0.5; migrate only into a new creator-first root with manual per-episode creator confirmation.",
   "Use only tools visible in the current DSH preset and preserve the upstream project ownership, freshness, review, and explicit production-confirmation contracts.",
+  "Use oh_story_production only for semantic production-view intents (open/focus, explicit shot order, or tracking a job that this Agent is actually executing). Cosmetic canvas layout remains creator-controlled. The tool changes only the Session projection: it does not edit creator documents, generate media, or authorize production.",
   "Production credentials remain outside project files. Never treat a prior acceptance, preview, continuation request, or budget discussion as confirmation for a paid production run.",
   "</short-drama-dsh-integration>"
 ].join("\n");
 var DSH_DRAMA_OVERRIDES = {
-  "short-drama": "A dashboard request means focus or use the native \u77ED\u5267 tab in this DSH Session. Do not run the bundled standalone Dashboard script.",
-  "short-drama-produce": "Use an upstream adapter only after the creator explicitly confirms the exact current job. DSH permissions and approval UI remain authoritative."
+  "short-drama": "A dashboard request means focus or use the native \u77ED\u5267 tab in this DSH Session. Do not run the bundled standalone Dashboard script. New projects follow only the v0.6 creator-first contract and create only documents required by the current request.",
+  "short-drama-produce": "Use an upstream adapter only after the creator explicitly confirms the exact current job. Its source must be the current creator-first Markdown and its output belongs under \u5267\u96C6/<EP>/\u5236\u4F5C\u6210\u679C/. DSH permissions and approval UI remain authoritative. When oh_story_production is visible, register the previewed job with track_job after the confirmation is valid and before run \u2014 never at prepare time \u2014 passing the same job ID, target, modality and count the creator just approved.",
+  "short-drama-assets": "Keep one stable `- ID\uFF1AVISUAL-*` line on every \u4EBA\u7269/\u9020\u578B/\u5730\u70B9/\u9053\u5177/\u72B6\u6001 entry in \u89C6\u89C9\u8BBE\u5B9A.md, and never change an existing ID when editing its heading or text. The \u751F\u4EA7 view identifies canvas nodes by that ID; entries without one still render, but the workbench reports their node identity as unstable."
 };
+var DSH_GAME_BRIDGE = [
+  "<novel-to-game-dsh-integration>",
+  "This Skill is a native contribution to the current DeepSeek Harness session.",
+  "DSH owns the workspace, model, preset, permissions, Session Log, tools, approvals, cancellation, resume, Todo, and Chat UI.",
+  "The \u6E38\u620F tab is the playable Game Studio. Never start a second Agent runtime, dashboard, session transport, or model configuration.",
+  "Keep the complete upstream seven-Skill pipeline and write adaptation artifacts under game-adaptations/<project>/ exactly as the upstream contracts specify.",
+  "For a web target, keep the authoritative playable entry at build/app/index.html so Game Studio can preview it. Do not silently replace a requested non-web runtime with a web build.",
+  "Use only DSH-visible tools and approvals. qa/verification.json remains the sole machine QA truth and must cover launch, render, input, coreLoop, outcome, and restart with real execution evidence.",
+  "The bundled Jin Ping Mei project is a read-only example, not a template to copy mechanically and not proof that another adaptation passed QA.",
+  "</novel-to-game-dsh-integration>"
+].join("\n");
+var DSH_VIDEO_BRIDGE = [
+  "<video-recap-dsh-integration>",
+  "This Skill is a native contribution to the current DeepSeek Harness session.",
+  "DSH owns the workspace, model, preset, permissions, Session Log, tools, approvals, cancellation, resume, Todo, Chat, and the \u89C6\u9891 preview Studio.",
+  "Never start a second Agent runtime, dashboard, session transport, web server, polling loop, or model configuration.",
+  "Keep the complete upstream six-Skill pipeline. Put each project under video-recaps/<project>/, copy or import source media under sources/, and use work/ as the upstream work_dir so the Studio can discover authoritative manifests and outputs.",
+  "The Video Studio is a preview and artifact surface, not a nonlinear editor. Do not invent a second project-state format, timeline truth, or render queue; recap_run_manifest.json, recap_phase.json, timeline.json, assembly_manifest.json, and the upstream artifacts remain authoritative.",
+  "MIMO_API_KEY, FISH_API_KEY, and voice credentials stay in the host environment. Never write secrets into project files, tool arguments shown to the browser, or chat output.",
+  "Use only DSH-visible tools and approvals. Run Python and ffmpeg through the current DSH execution world, preserve cancellation, and do not install or upgrade system dependencies without explicit user approval.",
+  "When a new edited or final video is ready, tell the user that Video Studio can load it; never interrupt playback by replacing the currently loaded video silently.",
+  "</video-recap-dsh-integration>"
+].join("\n");
 var DSH_NATIVE_SKILLS = {
   story: `# story \u2014 DSH \u5C0F\u8BF4\u6D41\u7A0B\u5165\u53E3
 
@@ -58,6 +87,9 @@ var DSH_NATIVE_SKILLS = {
 - \u5BFC\u5165\u5DF2\u6709\u4F5C\u54C1\uFF1Astory-import
 - \u5BA1\u7A3F\u4E0E\u53BB AI \u5473\uFF1Astory-review\u3001story-deslop
 - \u5C01\u9762\uFF1Astory-cover
+- \u7BA1\u7406\u4F5C\u8005\u4E60\u60EF\uFF08\u8BB0\u4F4F/\u67E5\u770B/\u786E\u8BA4/\u66FF\u6362/\u5FD8\u6389\u5199\u4F5C\u504F\u597D\uFF09\uFF1A\u52A0\u8F7D\u672C skill \u7684
+  references/author-memory.md\uFF0C\u53EA\u7528\u672C skill \u7684 scripts/author_memory_commit.py \u7BA1\u7406
+  \u5DE5\u4F5C\u533A\u7EA7 .story/\u4F5C\u8005\u8BB0\u5FC6/\uFF1B\u5DE5\u5177\u672A\u8FD4\u56DE Author Memory Receipt \u524D\u4E0D\u5F97\u58F0\u79F0\u5DF2\u8BB0\u4F4F\u3002
 
 \u610F\u56FE\u660E\u786E\u65F6\u76F4\u63A5\u8FDB\u5165\u5BF9\u5E94 Skill\uFF1B\u4E0D\u660E\u786E\u65F6\u53EA\u95EE\u4E00\u4E2A\u4F1A\u6539\u53D8\u6D41\u7A0B\u7684\u95EE\u9898\u3002\u9879\u76EE\u6587\u4EF6\u3001
 Agent\u3001\u6A21\u578B\u3001\u6743\u9650\u3001Session Log \u548C UI \u5747\u7531\u5F53\u524D DSH \u4F1A\u8BDD\u7BA1\u7406\u3002\u5C0F\u8BF4\u6587\u4EF6\u901A\u8FC7\u201C\u5C0F\u8BF4\u201D
@@ -71,7 +103,7 @@ Agent\u3001\u6A21\u578B\u3001\u6743\u9650\u3001Session Log \u548C UI \u5747\u753
 3. \u957F\u7BC7\u6309\u9700\u5EFA\u7ACB \u6B63\u6587/\u3001\u8BBE\u5B9A/\u3001\u5927\u7EB2/\u3001\u8FFD\u8E2A/\uFF0C\u5E76\u51C6\u5907\u8FFD\u8E2A/_tracking-state.json\uFF1B
    \u7B2C\u4E00\u7AE0\u6B63\u6587\u843D\u76D8\u524D\u5FC5\u987B\u6709\u5BF9\u5E94\u7EC6\u7EB2\u3002\u77ED\u7BC7\u4FDD\u6301\u8F7B\u91CF\u7ED3\u6784\uFF0C\u4E0D\u5F3A\u52A0\u957F\u7BC7 Tracking\u3002
 4. \u9700\u8981\u67B6\u6784\u3001\u89D2\u8272\u6216\u7814\u7A76\u5DE5\u4F5C\u65F6\uFF0C\u901A\u8FC7 oh_story_role \u8C03\u7528\u5DF2\u6253\u5305 Role\uFF1B\u4E0D\u8981\u68C0\u67E5\u6216
-   \u751F\u6210 .claude\u3001.codex\u3001.opencode\u3001.zcode\u3001AGENTS.md \u6216 .story-deployed\u3002
+   \u751F\u6210 .claude\u3001.codex\u3001.opencode\u3001.agents\u3001.zcode\u3001AGENTS.md \u6216 .story-deployed\u3002
 5. \u590D\u8FF0\u521B\u5EFA\u3001\u4FDD\u7559\u548C\u5F85\u7528\u6237\u786E\u8BA4\u7684\u6587\u4EF6\u3002\u4E0D\u8981\u914D\u7F6E\u6A21\u578B\u3001\u6743\u9650\u3001Hooks \u6216 Session\u3002
 
 \u9898\u6750\u3001\u89D2\u8272\u3001\u8282\u594F\u3001\u51B2\u7A81\u3001\u5F00\u7BC7\u548C\u5199\u4F5C\u65B9\u6CD5\u8D44\u6599\u4F4D\u4E8E references/agent-references/\uFF1B
@@ -119,9 +151,19 @@ Agent\u3001\u6A21\u578B\u3001\u6743\u9650\u3001Session Log \u548C UI \u5747\u753
 \u4E0D\u8981\u542F\u52A8 CDP\u3001\u72EC\u7ACB\u6D4F\u89C8\u5668\u6216\u5E76\u884C\u8FD0\u884C\u65F6\u3002`
 };
 function frontmatterValue(frontmatter, key) {
-  const match = new RegExp(`^${key}:\\s*(.+)$`, "mu").exec(frontmatter);
-  const raw = match?.[1]?.trim();
+  const lines = frontmatter.split(/\r?\n/u);
+  const index = lines.findIndex((line) => new RegExp(`^${key}:\\s*`, "u").test(line));
+  if (index < 0) return void 0;
+  const raw = lines[index]?.replace(new RegExp(`^${key}:\\s*`, "u"), "").trim();
   if (raw === void 0) return void 0;
+  if (raw === ">" || raw === "|" || raw === ">-" || raw === "|-") {
+    const values = [];
+    for (const line of lines.slice(index + 1)) {
+      if (/^\S/u.test(line)) break;
+      values.push(line.trim());
+    }
+    return (raw.startsWith(">") ? values.join(" ") : values.join("\n")).trim();
+  }
   if (raw.startsWith('"') && raw.endsWith('"')) {
     try {
       return JSON.parse(raw);
@@ -138,7 +180,12 @@ function parseBundledSkill(source) {
   const description = frontmatterValue(match[1], "description");
   if (!name2 || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(name2)) throw new Error("Bundled skill has an invalid name.");
   if (!description) throw new Error(`Bundled skill "${name2}" has no description.`);
-  return { name: name2, description, content: source.slice(match[0].length) };
+  return {
+    name: name2,
+    description,
+    content: source.slice(match[0].length),
+    userInvocable: frontmatterValue(match[1], "user-invocable") !== "false"
+  };
 }
 function dshSkillContent(name2, content) {
   const override = DSH_SKILL_OVERRIDES[name2];
@@ -156,6 +203,10 @@ function defaultDramaSkillRoot() {
   const current = dirname(fileURLToPath(import.meta.url));
   return basename(current) === "src" ? resolve(current, "../../knowledge/drama/skills") : resolve(current, "drama/skills");
 }
+function defaultNovelToGameSkillRoot() {
+  const current = dirname(fileURLToPath(import.meta.url));
+  return basename(current) === "src" ? resolve(current, "../../knowledge/novel-to-game/skills") : resolve(current, "novel-to-game/skills");
+}
 function createBundledSkillProvider(providerName, skillRoot, content) {
   const root = resolve(skillRoot);
   return {
@@ -169,7 +220,7 @@ function createBundledSkillProvider(providerName, skillRoot, content) {
         return {
           name: parsed.name,
           description: parsed.description,
-          invocation: INVOCATION,
+          invocation: { modelInvocable: true, userInvocable: parsed.userInvocable },
           provider: providerName,
           source: "bundled",
           resourceBase: { kind: "directory", path: join(root, directory) },
@@ -191,7 +242,7 @@ function createBundledSkillProvider(providerName, skillRoot, content) {
       return {
         name: parsed.name,
         description: parsed.description,
-        invocation: INVOCATION,
+        invocation: { modelInvocable: true, userInvocable: parsed.userInvocable },
         provider: providerName,
         source: "bundled",
         resourceBase: { kind: "directory", path: join(root, parsed.name) },
@@ -214,18 +265,38 @@ ${content}`;
 function createDramaSkillProvider(skillRoot = defaultDramaSkillRoot()) {
   return createBundledSkillProvider(DRAMA_PROVIDER_NAME, skillRoot, dshDramaSkillContent);
 }
+function dshNovelToGameSkillContent(_name, content) {
+  return `${DSH_GAME_BRIDGE}
+
+${content}`;
+}
+function createNovelToGameSkillProvider(skillRoot = defaultNovelToGameSkillRoot()) {
+  return createBundledSkillProvider(GAME_PROVIDER_NAME, skillRoot, dshNovelToGameSkillContent);
+}
+function defaultVideoRecapSkillRoot() {
+  const current = dirname(fileURLToPath(import.meta.url));
+  return basename(current) === "src" ? resolve(current, "../../knowledge/video-recap/skills") : resolve(current, "video-recap/skills");
+}
+function dshVideoRecapSkillContent(_name, content) {
+  return `${DSH_VIDEO_BRIDGE}
+
+${content}`;
+}
+function createVideoRecapSkillProvider(skillRoot = defaultVideoRecapSkillRoot()) {
+  return createBundledSkillProvider(VIDEO_PROVIDER_NAME, skillRoot, dshVideoRecapSkillContent);
+}
 
 // src/native-hooks.ts
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 var MUTATION_TOOLS = /* @__PURE__ */ new Set(["write", "edit", "str_replace_editor"]);
 function mutationPath(name2, args) {
   if (!MUTATION_TOOLS.has(name2) || typeof args !== "object" || args === null || Array.isArray(args)) return void 0;
-  const record = args;
+  const record2 = args;
   if (name2 === "str_replace_editor") {
-    if (!(/* @__PURE__ */ new Set(["create", "str_replace", "insert"])).has(String(record.command))) return void 0;
-    return typeof record.path === "string" && record.path.trim() !== "" ? record.path : void 0;
+    if (!(/* @__PURE__ */ new Set(["create", "str_replace", "insert"])).has(String(record2.command))) return void 0;
+    return typeof record2.path === "string" && record2.path.trim() !== "" ? record2.path : void 0;
   }
-  return typeof record.file_path === "string" && record.file_path.trim() !== "" ? record.file_path : void 0;
+  return typeof record2.file_path === "string" && record2.file_path.trim() !== "" ? record2.file_path : void 0;
 }
 function normalizedRelativePath(path) {
   const segments = [];
@@ -320,11 +391,89 @@ function registerOhStoryHooks(context) {
 }
 
 // src/role-tool.ts
+import { defineTool as defineTool2 } from "@deepseek-ai/dsh-tools";
+
+// src/reference-tool.ts
+import { readdir as readdir2, readFile as readFile2, realpath } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2 } from "node:path";
 import { defineTool } from "@deepseek-ai/dsh-tools";
+var OH_STORY_REFERENCE_TOOL_NAME = "oh_story_bundled_reference";
+async function collectMarkdown(root, directory = root) {
+  const entries = await readdir2(directory, { withFileTypes: true });
+  const nested = await Promise.all(entries.map(async (entry) => {
+    const path = join2(directory, entry.name);
+    if (entry.isDirectory()) return collectMarkdown(root, path);
+    return entry.isFile() && entry.name.endsWith(".md") ? [path] : [];
+  }));
+  return nested.flat();
+}
+async function bundledReferences(storySetupRoot) {
+  const root = await realpath(resolve2(storySetupRoot));
+  const referenceRoot = await realpath(join2(root, "references", "agent-references"));
+  const referenceDirectory = relative2(root, referenceRoot);
+  if (referenceDirectory === "" || referenceDirectory.startsWith("..") || isAbsolute2(referenceDirectory)) {
+    throw new Error("Bundled Oh Story reference directory escaped its package root.");
+  }
+  const values = await Promise.all((await collectMarkdown(referenceRoot)).map(async (path) => {
+    const canonicalPath = await realpath(path);
+    const inside = relative2(referenceRoot, canonicalPath);
+    if (inside === "" || inside.startsWith("..") || isAbsolute2(inside)) {
+      throw new Error(`Bundled Oh Story reference escaped its package root: ${path}`);
+    }
+    return {
+      canonicalPath,
+      name: `story-setup/references/agent-references/${inside.replaceAll("\\", "/")}`
+    };
+  }));
+  return values.sort((left, right) => left.name.localeCompare(right.name));
+}
+async function createOhStoryReferenceTool(storySetupRoot = join2(defaultBundledSkillRoot(), "story-setup")) {
+  const references = await bundledReferences(storySetupRoot);
+  if (references.length === 0) throw new Error("No bundled Oh Story references were found.");
+  const paths = references.map((reference) => reference.name);
+  const byName = new Map(references.map((reference) => [reference.name, reference.canonicalPath]));
+  return defineTool({
+    name: OH_STORY_REFERENCE_TOOL_NAME,
+    description: "Read one exact, pinned Oh Story story-setup reference bundled with this plugin. This does not resolve project Skills or workspace files.",
+    parameters: {
+      reference: {
+        type: "string",
+        required: true,
+        enum: paths,
+        description: "The exact story-setup reference path named by the active bundled Role."
+      }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          reference: { type: "string", required: true },
+          content: { type: "string", required: true }
+        }
+      },
+      render: (_args, value) => [{
+        type: "text",
+        text: `Bundled Oh Story reference: ${value.reference}
+
+${value.content}`
+      }]
+    },
+    isConcurrencySafe: () => true,
+    async execute(args) {
+      const path = byName.get(args.reference);
+      if (path === void 0) throw new Error(`Oh Story reference is not bundled: ${args.reference}`);
+      return { reference: args.reference, content: await readFile2(path, "utf8") };
+    }
+  });
+}
+function bundledReferenceGuard(definition, tools) {
+  return (execution) => execution.name === OH_STORY_REFERENCE_TOOL_NAME && tools.get(OH_STORY_REFERENCE_TOOL_NAME, execution.agent) !== definition ? "The pinned Oh Story reference tool was shadowed in this Agent scope." : void 0;
+}
 
 // src/role-provider.ts
-import { readFile as readFile2 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+import { readFile as readFile3 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2, join as join3, resolve as resolve3 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var OH_STORY_ROLE_NAMES = [
   "chapter-extractor",
@@ -341,10 +490,10 @@ function roleBody(source) {
 }
 function defaultBundledRoleRoot() {
   const current = dirname2(fileURLToPath2(import.meta.url));
-  return basename2(current) === "src" ? resolve2(current, "../../knowledge/oh-story/roles") : resolve2(current, "oh-story/roles");
+  return basename2(current) === "src" ? resolve3(current, "../../knowledge/oh-story/roles") : resolve3(current, "oh-story/roles");
 }
 async function loadBundledRole(name2, roleRoot = defaultBundledRoleRoot(), execution = "tool-free") {
-  const body = roleBody(await readFile2(join2(resolve2(roleRoot), `${name2}.md`), "utf8"));
+  const body = roleBody(await readFile3(join3(resolve3(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.",
@@ -353,6 +502,8 @@ async function loadBundledRole(name2, roleRoot = defaultBundledRoleRoot(), execu
   ] : [
     "You are running as a native oh-story-dsh specialist. The current DSH workspace and visible tool set are your complete authority boundary.",
     "Never inspect or require legacy .claude/.opencode/.codex agent deployment files; this exact pinned Role is already active.",
+    "Bundled story-setup references are pinned plugin resources, not project files or project Skills. When the upstream Role marks one mandatory, call oh_story_bundled_reference with the exact story-setup/references/agent-references path, then use only the returned content.",
+    "If oh_story_bundled_reference or a required bundled reference is unavailable, report the missing reference to the caller. Never call the generic skill tool, fall back to a legacy platform path, or claim that an unread reference was used.",
     "Use only the tools actually visible to you. Mutate files only when the caller explicitly requests it and your visible DSH tools permit it; otherwise return findings to the caller."
   ];
   return [
@@ -367,10 +518,10 @@ 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", "write", "edit"],
-  "consistency-checker": ["read", "glob", "grep"],
-  "narrative-writer": ["read", "glob", "grep", "write", "edit", "bash"],
-  "story-architect": ["read", "glob", "grep", "write", "edit"],
+  "character-designer": [OH_STORY_REFERENCE_TOOL_NAME, "read", "glob", "grep", "write", "edit"],
+  "consistency-checker": [OH_STORY_REFERENCE_TOOL_NAME, "read", "glob", "grep"],
+  "narrative-writer": [OH_STORY_REFERENCE_TOOL_NAME, "read", "glob", "grep", "write", "edit", "bash"],
+  "story-architect": [OH_STORY_REFERENCE_TOOL_NAME, "read", "glob", "grep", "write", "edit"],
   "story-explorer": ["read", "glob", "grep"],
   "story-researcher": ["read", "glob", "grep", "bash", "write", "web_search", "web_fetch"]
 };
@@ -380,12 +531,12 @@ function roleToolFilter(role) {
 function resultText(output) {
   return output.map((block) => block.type === "text" ? block.text : JSON.stringify(block)).join("\n");
 }
-async function createOhStoryRoleTool() {
+async function createOhStoryRoleTool(subagents) {
   const personas = /* @__PURE__ */ new Map();
   await Promise.all(OH_STORY_ROLE_NAMES.map(async (role) => {
     personas.set(role, await loadBundledRole(role, void 0, "native-tools"));
   }));
-  return defineTool({
+  return defineTool2({
     name: OH_STORY_ROLE_TOOL_NAME,
     description: "Run one focused Oh Story specialist as a child of the current DSH Agent. The child inherits DSH model, workspace, permissions, lifecycle, and UI.",
     parameters: {
@@ -419,7 +570,9 @@ async function createOhStoryRoleTool() {
       const persona = personas.get(args.role);
       if (persona === void 0) throw new Error(`Oh Story Role ${args.role} is not bundled.`);
       const allowed = roleToolFilter(args.role).allow.filter((name2) => exec.agent?.ctx.tools.get(name2, exec.agent) !== void 0);
-      const run = await exec.agent.ctx.subagents.start("spawn", {
+      const runtime = subagents ?? exec.agent.ctx.get("subagents");
+      if (runtime === void 0) throw new Error("oh_story_role requires the DSH subagent runtime.");
+      const run = await runtime.start("spawn", {
         label: `oh-story:${args.role}`,
         prompt: [{ type: "text", text: args.prompt }],
         parent: exec.agent,
@@ -445,7 +598,12 @@ async function createOhStoryRoleTool() {
   });
 }
 async function registerOhStoryRoleTool(context) {
-  const definition = await createOhStoryRoleTool();
+  const [definition, referenceDefinition] = await Promise.all([
+    createOhStoryRoleTool(context.subagents),
+    createOhStoryReferenceTool()
+  ]);
+  context.tools.register(referenceDefinition);
+  context.tools.guard(bundledReferenceGuard(referenceDefinition, context.tools));
   let dispose;
   const mount = () => {
     dispose ??= context.tools.register(definition);
@@ -463,11 +621,290 @@ async function registerOhStoryRoleTool(context) {
   if (context.subagents.getProvider("spawn") !== void 0) mount();
 }
 
+// src/production-tool.ts
+import { defineTool as defineTool3 } from "@deepseek-ai/dsh-tools";
+
+// src/production-intent.ts
+var OH_STORY_PRODUCTION_TOOL_NAME = "oh_story_production";
+var PRODUCTION_INTENT_ACTIONS = [
+  "open_section",
+  "focus_target",
+  "set_sequence",
+  "track_job"
+];
+var PRODUCTION_INTENT_SECTIONS = ["shots", "assets", "tasks", "sequence", "canvas"];
+var PRODUCTION_INTENT_JOB_KINDS = ["image", "video", "composition"];
+function requiredText(value, field) {
+  const normalized = value?.trim();
+  if (!normalized) throw new Error(`oh_story_production ${field} is required for this action.`);
+  if (normalized.length > 512) throw new Error(`oh_story_production ${field} is too long.`);
+  return normalized;
+}
+function validateProductionIntent(args) {
+  const episode = args.episode.trim().replaceAll("\\", "/").replace(/\/$/u, "");
+  if (!/^剧集\/EP\d{3,}$/u.test(episode)) {
+    throw new Error("oh_story_production episode must use the creator path form \u5267\u96C6/EP001.");
+  }
+  if (args.action === "open_section") {
+    if (args.section === void 0) throw new Error("oh_story_production section is required for open_section.");
+    return { action: args.action, episode, section: args.section };
+  }
+  if (args.action === "focus_target") {
+    return { action: args.action, episode, targetId: requiredText(args.targetId, "targetId"), section: args.section };
+  }
+  if (args.action === "set_sequence") {
+    const shotIds = args.shotIds?.map((value) => value.trim()).filter((value) => value !== "") ?? [];
+    if (shotIds.length === 0) throw new Error("oh_story_production shotIds must contain at least one shot for set_sequence.");
+    if (shotIds.length > 500 || new Set(shotIds).size !== shotIds.length || shotIds.some((value) => !/^SHOT-[A-Z0-9-]+$/u.test(value))) {
+      throw new Error("oh_story_production shotIds must be unique canonical SHOT-* identifiers.");
+    }
+    return { action: args.action, episode, shotIds };
+  }
+  const expectedOutputs = args.expectedOutputs;
+  if (expectedOutputs !== void 0 && (!Number.isInteger(expectedOutputs) || expectedOutputs < 1 || expectedOutputs > 500)) {
+    throw new Error("oh_story_production expectedOutputs must be an integer between 1 and 500.");
+  }
+  if (args.jobKind === void 0) throw new Error("oh_story_production jobKind is required for track_job.");
+  const prompt = args.prompt?.trim();
+  return {
+    action: args.action,
+    episode,
+    jobId: requiredText(args.jobId, "jobId"),
+    targetId: requiredText(args.targetId, "targetId"),
+    jobKind: args.jobKind,
+    expectedOutputs,
+    prompt: prompt === "" ? void 0 : prompt
+  };
+}
+
+// src/production-tool.ts
+function intentMessage(intent) {
+  if (intent.action === "track_job") return `\u5DF2\u628A ${intent.targetId ?? "\u751F\u4EA7\u5BF9\u8C61"} \u7684 ${intent.jobKind ?? "\u5A92\u4F53"} \u4EFB\u52A1\u6295\u5F71\u5230 ${intent.episode} \u7684\u4EFB\u52A1\u677F\u3002`;
+  if (intent.action === "set_sequence") return `\u5DF2\u628A ${String(intent.shotIds?.length ?? 0)} \u4E2A\u955C\u5934\u7684\u987A\u5E8F\u53D1\u9001\u5230 ${intent.episode} \u6210\u7247\u89C6\u56FE\u3002`;
+  if (intent.action === "focus_target") return `\u5DF2\u8BF7\u6C42 ${intent.episode} \u751F\u4EA7\u89C6\u56FE\u805A\u7126 ${intent.targetId ?? "\u76EE\u6807"}\u3002`;
+  return `\u5DF2\u628A ${intent.action} \u754C\u9762\u610F\u56FE\u53D1\u9001\u5230 ${intent.episode} \u751F\u4EA7\u5DE5\u4F5C\u53F0\u3002`;
+}
+function createOhStoryProductionTool() {
+  return defineTool3({
+    name: OH_STORY_PRODUCTION_TOOL_NAME,
+    description: "Operate the native oh-story short-drama production projection in the current DSH Session. It can open or focus semantic production targets, set an explicit shot order, or track a job the Agent is actually executing. It never controls cosmetic canvas layout, generates media, changes creator documents, or counts as creator confirmation for paid production.",
+    parameters: {
+      action: { type: "string", required: true, enum: PRODUCTION_INTENT_ACTIONS, description: "The exact production UI/task projection operation." },
+      episode: { type: "string", required: true, description: "Creator-first episode directory, for example \u5267\u96C6/EP001." },
+      section: { type: "string", enum: PRODUCTION_INTENT_SECTIONS },
+      targetId: { type: "string" },
+      shotIds: { type: "array", items: { type: "string" } },
+      jobId: { type: "string", description: "Stable ID that must also appear in produced output filenames." },
+      jobKind: { type: "string", enum: PRODUCTION_INTENT_JOB_KINDS },
+      expectedOutputs: { type: "integer", description: "Number of media files this job will produce. Repeat the count the creator approved when re-registering a batch; omit it to keep the count the workbench already recorded." },
+      prompt: { type: "string", description: "Exact prompt/specification for a tracked job; not a production authorization." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          action: { type: "string", required: true, enum: PRODUCTION_INTENT_ACTIONS },
+          episode: { type: "string", required: true },
+          message: { type: "string", required: true }
+        }
+      },
+      render: (_args, value) => [{ type: "text", text: value.message }]
+    },
+    isConcurrencySafe: () => true,
+    execute(args) {
+      const intent = validateProductionIntent(args);
+      return Promise.resolve({ action: intent.action, episode: intent.episode, message: intentMessage(intent) });
+    }
+  });
+}
+function registerOhStoryProductionTool(context) {
+  context.tools.register(createOhStoryProductionTool());
+}
+
 // src/workspace-route.ts
-import { extname } from "node:path";
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { readFile as readNodeFile, realpath as nodeRealpath, stat as nodeStat } from "node:fs/promises";
+import { extname as extname2, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve4 } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { FsError } from "@deepseek-ai/dsh-fs";
 import { SessionId } from "@deepseek-ai/dsh-session";
 
+// src/game-verification.ts
+var WorkspaceVerificationTracker = class {
+  #observations = /* @__PURE__ */ new Map();
+  observe(key, verificationRevision, previewVersion) {
+    const previous = this.#observations.get(key);
+    if (previous === void 0) {
+      this.#remember(key, { verificationRevision, previewVersion, bound: false });
+      return { binding: "UNBOUND" };
+    }
+    if (verificationRevision !== previous.verificationRevision) {
+      const bound = verificationRevision !== void 0;
+      this.#remember(key, { verificationRevision, previewVersion, bound });
+      return bound ? { binding: "CURRENT", verifiedPreviewVersion: previewVersion } : { binding: "UNBOUND" };
+    }
+    if (!previous.bound) return { binding: "UNBOUND" };
+    return previewVersion === previous.previewVersion ? { binding: "CURRENT", verifiedPreviewVersion: previous.previewVersion } : { binding: "STALE", verifiedPreviewVersion: previous.previewVersion };
+  }
+  #remember(key, observation) {
+    this.#observations.set(key, observation);
+    if (this.#observations.size <= 500) return;
+    const oldest = this.#observations.keys().next();
+    if (!oldest.done) this.#observations.delete(oldest.value);
+  }
+};
+
+// src/video-project.ts
+import { basename as basename3, extname } from "node:path";
+var VIDEO_DIRECTORY = "video-recaps";
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".mov", ".mkv", ".webm"]);
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["frames", "tts_segments", "asr_chunks", "chunks", "cache", "tmp", ".subtitle_measure"]);
+var VISIBLE_TEXT_FILES = /* @__PURE__ */ new Set([
+  "project.json",
+  "recap_run_manifest.json",
+  "recap_phase.json",
+  "agent_narration_brief.md",
+  "recap_story_plan.json",
+  "visual_audio_board.json",
+  "clip_plan.json",
+  "clip_plan_validated.json",
+  "narration.json",
+  "narration_review.md",
+  "tts_meta.json",
+  "timeline.json",
+  "assembly_manifest.json",
+  "assembly_qc.json",
+  "final_qc.json",
+  "final_qc.md",
+  "delivery_qc.json",
+  "subtitles.srt",
+  "subtitles.ass"
+]);
+var ARTIFACT_META = {
+  "recap_run_manifest.json": { label: "\u8FD0\u884C\u6E05\u5355", kind: "manifest" },
+  "recap_phase.json": { label: "\u9636\u6BB5\u8D26\u672C", kind: "manifest" },
+  "agent_narration_brief.md": { label: "\u89E3\u8BF4 Brief", kind: "plan" },
+  "recap_story_plan.json": { label: "\u6545\u4E8B\u65B9\u6848", kind: "plan" },
+  "visual_audio_board.json": { label: "\u97F3\u753B\u65B9\u6848", kind: "plan" },
+  "clip_plan.json": { label: "\u526A\u8F91\u8BA1\u5212", kind: "plan" },
+  "clip_plan_validated.json": { label: "\u5DF2\u6821\u9A8C\u526A\u8F91\u8BA1\u5212", kind: "plan" },
+  "narration.json": { label: "\u89E3\u8BF4\u8BCD", kind: "script" },
+  "narration_review.md": { label: "\u89E3\u8BF4\u590D\u6838", kind: "quality" },
+  "timeline.json": { label: "\u6210\u7247\u65F6\u95F4\u7EBF", kind: "plan" },
+  "assembly_manifest.json": { label: "\u5408\u6210\u6E05\u5355", kind: "manifest" },
+  "assembly_qc.json": { label: "\u5408\u6210\u8D28\u68C0", kind: "quality" },
+  "final_qc.json": { label: "\u6700\u7EC8\u8D28\u68C0", kind: "quality" },
+  "final_qc.md": { label: "\u6700\u7EC8\u8D28\u68C0\u62A5\u544A", kind: "quality" },
+  "delivery_qc.json": { label: "\u4EA4\u4ED8\u8D28\u68C0", kind: "quality" },
+  "subtitles.srt": { label: "SRT \u5B57\u5E55", kind: "subtitle" },
+  "subtitles.ass": { label: "ASS \u5B57\u5E55", kind: "subtitle" }
+};
+function videoProjectRoot(path) {
+  const parts = path.split("/");
+  const name2 = parts[1];
+  if (parts[0] !== VIDEO_DIRECTORY || name2 === void 0 || name2 === "" || name2 === "." || name2 === ".." || name2.startsWith(".") || name2.includes("\\") || name2.length > 128) return void 0;
+  return `${VIDEO_DIRECTORY}/${name2}`;
+}
+function skipVideoDirectory(path) {
+  const parts = path.split("/");
+  return parts[0] === VIDEO_DIRECTORY && parts.length >= 3 && SKIPPED_DIRECTORIES.has(parts.at(-1) ?? "");
+}
+function visibleVideoPath(path) {
+  const root = videoProjectRoot(path);
+  if (root === void 0 || path === root) return false;
+  const name2 = basename3(path);
+  const extension = extname(name2).toLocaleLowerCase();
+  if (VISIBLE_TEXT_FILES.has(name2)) return true;
+  if (!VIDEO_EXTENSIONS.has(extension)) return false;
+  return path.startsWith(`${root}/sources/`) || path.startsWith(`${root}/outputs/`) || name2 === "edited_source.mp4" || /^recap_.+\.(?:mp4|mov|webm)$/iu.test(name2);
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function text(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function referencedMedia(files, value) {
+  const path = text(value)?.replaceAll("\\", "/");
+  if (path === void 0) return void 0;
+  const direct = files.find((file) => file.path === path || path.endsWith(`/${file.path}`));
+  if (direct !== void 0) return direct;
+  const name2 = path.split("/").at(-1);
+  const matching = files.filter((file) => file.path.split("/").at(-1) === name2);
+  return matching.length === 1 ? matching[0] : void 0;
+}
+function previewAsset(file, role, label) {
+  return file.kind === "media" && file.mimeType?.startsWith("video/") === true ? { role, label, path: file.path, bytes: file.bytes, version: file.version, mimeType: file.mimeType } : void 0;
+}
+function summarizeVideoProject(root, files, metadata2 = {}) {
+  const id = root.slice(`${VIDEO_DIRECTORY}/`.length);
+  const projectFiles = files.filter((file) => file.path.startsWith(`${root}/`));
+  const project = record(metadata2.project);
+  const manifest = record(metadata2.runManifest);
+  const settings = record(manifest?.settings);
+  const assembly = record(metadata2.assembly);
+  const source = referencedMedia(projectFiles, manifest?.source_video) ?? projectFiles.find((file) => file.kind === "media" && file.path.startsWith(`${root}/sources/`) && file.mimeType?.startsWith("video/") === true);
+  const edited = projectFiles.find((file) => file.path.split("/").at(-1) === "edited_source.mp4");
+  const final = referencedMedia(projectFiles, assembly?.final_output) ?? projectFiles.filter((file) => file.kind === "media" && (file.path.startsWith(`${root}/outputs/`) || /^recap_.+\.(?:mp4|mov|webm)$/iu.test(file.path.split("/").at(-1) ?? ""))).at(-1);
+  const previews = [
+    source === void 0 ? void 0 : previewAsset(source, "source", "\u539F\u7247"),
+    edited === void 0 ? void 0 : previewAsset(edited, "edited", "\u526A\u540E\u7247"),
+    final === void 0 ? void 0 : previewAsset(final, "final", "\u6700\u7EC8\u6210\u7247")
+  ].filter((value) => value !== void 0);
+  const names = new Set(projectFiles.map((file) => file.path.split("/").at(-1)));
+  const cutMode = settings?.edit_mode === "cut" || names.has("clip_plan.json") || edited !== void 0;
+  let state = "not-started";
+  let stage = "source";
+  let stageLabel = source === void 0 ? "\u7B49\u5F85\u5BFC\u5165\u89C6\u9891" : "\u53EF\u4EE5\u5F00\u59CB";
+  let nextArtifact;
+  if (final !== void 0) {
+    state = "ready";
+    stage = "complete";
+    stageLabel = "\u6210\u7247\u5DF2\u5C31\u7EEA";
+  } else if (names.has("tts_meta.json")) {
+    state = "working";
+    stage = "assemble";
+    stageLabel = "\u6B63\u5728\u5408\u6210";
+  } else if (names.has("narration.json")) {
+    state = "working";
+    stage = "voiceover";
+    stageLabel = "\u914D\u97F3\u4E0E\u5408\u6210";
+  } else if (cutMode && edited !== void 0) {
+    state = "waiting";
+    stage = "narration";
+    stageLabel = "\u7B49\u5F85\u89E3\u8BF4\u8BCD";
+    nextArtifact = "narration.json";
+  } else if (cutMode && names.has("clip_plan.json")) {
+    state = "working";
+    stage = "cut";
+    stageLabel = "\u6B63\u5728\u526A\u8F91";
+  } else if (manifest !== void 0) {
+    state = "waiting";
+    stage = cutMode ? "clip-plan" : "narration";
+    stageLabel = cutMode ? "\u7B49\u5F85\u526A\u8F91\u8BA1\u5212" : "\u7B49\u5F85\u89E3\u8BF4\u8BCD";
+    nextArtifact = cutMode ? "clip_plan.json" : "narration.json";
+  }
+  const artifacts = projectFiles.flatMap((file) => {
+    const name2 = file.path.split("/").at(-1) ?? "";
+    const meta = ARTIFACT_META[name2];
+    return meta === void 0 ? [] : [{ ...meta, path: file.path, version: file.version }];
+  }).sort((left, right) => left.path.localeCompare(right.path, "zh-Hans-CN"));
+  return {
+    id,
+    root,
+    title: text(project?.title) ?? id,
+    state,
+    stage,
+    stageLabel,
+    nextArtifact,
+    previews,
+    artifacts
+  };
+}
+
 // src/workspace-request-trust.ts
 function header(headers, name2) {
   if (headers instanceof Headers) return headers.get(name2) ?? void 0;
@@ -517,14 +954,45 @@ function isTrustedWorkspaceRequest(request, trustedHosts) {
     return false;
   }
 }
+function isTrustedPreviewNavigation(request, trustedHosts) {
+  if (isTrustedWorkspaceRequest(request, trustedHosts)) return true;
+  const authority = header(request.headers, "host");
+  if (authority === void 0) return false;
+  const host = parseAuthority(authority);
+  if (host === void 0 || !isLoopbackHostname(host.hostname) && !isTrustedAuthority(host, trustedHosts)) return false;
+  return header(request.headers, "origin") === void 0 && header(request.headers, "sec-fetch-site") === "cross-site" && header(request.headers, "sec-fetch-mode") === "navigate" && ["document", "iframe"].includes(header(request.headers, "sec-fetch-dest") ?? "");
+}
 
 // src/workspace-route.ts
 var STORY_DIRECTORIES = ["\u6B63\u6587", "\u5927\u7EB2", "\u8BBE\u5B9A", "\u8FFD\u8E2A", "\u5BF9\u6807", "\u53C2\u8003\u8D44\u6599"];
 var DRAMA_DIRECTORIES = ["\u8F93\u5165", "\u9879\u76EE\u5F00\u53D1", "\u8BBE\u5B9A\u96C6", "\u5267\u96C6", "\u4EA4\u4ED8", "\u521B\u4F5C\u8005\u51B3\u7B56", "\u5BA1\u67E5"];
-var CREATIVE_DIRECTORIES = [...STORY_DIRECTORIES, ...DRAMA_DIRECTORIES];
+var GAME_DIRECTORY = "game-adaptations";
+var CREATIVE_DIRECTORIES = [VIDEO_DIRECTORY, GAME_DIRECTORY, ...STORY_DIRECTORIES, ...DRAMA_DIRECTORIES];
 var ROOT_FILES = /* @__PURE__ */ new Set(["short-drama.json"]);
 var EDITABLE_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".json", ".jsonl"]);
+var GAME_EDITABLE_EXTENSIONS = /* @__PURE__ */ new Set([...EDITABLE_EXTENSIONS, ".html", ".css", ".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx"]);
+var VIDEO_EDITABLE_EXTENSIONS = /* @__PURE__ */ new Set([...EDITABLE_EXTENSIONS, ".srt", ".ass"]);
+var MEDIA_TYPES = /* @__PURE__ */ new Map([
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".webp", "image/webp"],
+  [".gif", "image/gif"],
+  [".mp4", "video/mp4"],
+  [".webm", "video/webm"],
+  [".mov", "video/quicktime"],
+  [".mkv", "video/x-matroska"],
+  [".mp3", "audio/mpeg"],
+  [".wav", "audio/wav"],
+  [".m4a", "audio/mp4"]
+]);
+var MEDIA_MAX_BYTES = 256 * 1024 * 1024;
 var FILE_LIMIT = 1e3;
+var PREVIEW_FILE_LIMIT = 32 * 1024 * 1024;
+var BUNDLED_GAME_EXAMPLE = "jin-ping-mei";
+var workspaceVerificationTracker = new WorkspaceVerificationTracker();
+var execFileAsync = promisify(execFile);
+var videoPreflightCache;
 var WorkspaceHttpError = class extends Error {
   constructor(status, message) {
     super(message);
@@ -532,6 +1000,53 @@ var WorkspaceHttpError = class extends Error {
   }
   status;
 };
+async function commandOutput(command, args) {
+  try {
+    const { stdout, stderr } = await execFileAsync(command, [...args], { encoding: "utf8", timeout: 5e3, maxBuffer: 4 * 1024 * 1024 });
+    return `${stdout}${stderr}`.trim();
+  } catch {
+    return void 0;
+  }
+}
+function pythonVersion(value) {
+  const match = /Python\s+(\d+)\.(\d+)(?:\.(\d+))?/u.exec(value ?? "");
+  if (match === null) return { ok: false };
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  return { ok: major > 3 || major === 3 && minor >= 10, version: match[0].replace(/^Python\s+/u, "") };
+}
+function configured(...names) {
+  return names.some((name2) => (process.env[name2] ?? "") !== "");
+}
+async function videoPreflight() {
+  if (videoPreflightCache !== void 0 && videoPreflightCache.expires > Date.now()) return videoPreflightCache.value;
+  let python = { ok: false };
+  for (const command of ["python3", "python"]) {
+    const parsed = pythonVersion(await commandOutput(command, ["--version"]));
+    if (parsed.version !== void 0) {
+      python = parsed;
+      break;
+    }
+  }
+  const [ffmpegOutput, ffmpegFilters, ffprobeOutput] = await Promise.all([
+    commandOutput("ffmpeg", ["-version"]),
+    commandOutput("ffmpeg", ["-hide_banner", "-filters"]),
+    commandOutput("ffprobe", ["-version"])
+  ]);
+  const value = {
+    python,
+    ffmpeg: { ok: ffmpegOutput !== void 0, subtitles: /\bsubtitles\b/u.test(ffmpegFilters ?? "") },
+    ffprobe: { ok: ffprobeOutput !== void 0 },
+    credentials: {
+      // Upstream falls back to the shared MIMO_API_KEY only when a per-service key is unset.
+      mimo: configured("MIMO_API_KEY", "MIMO_VIDEO_API_KEY", "MIMO_TTS_API_KEY", "MIMO_ASR_API_KEY"),
+      fish: configured("FISH_API_KEY"),
+      ttsProvider: process.env.TTS_PROVIDER ?? "mimo"
+    }
+  };
+  videoPreflightCache = { expires: Date.now() + 3e4, value };
+  return value;
+}
 function send(response, status, value) {
   const body = `${JSON.stringify(value)}
 `;
@@ -543,6 +1058,87 @@ function send(response, status, value) {
   });
   response.end(body);
 }
+function parseByteRange(value, size) {
+  const match = value === void 0 ? null : /^bytes=(\d*)-(\d*)$/u.exec(value.trim());
+  if (match === null) return void 0;
+  const left = match[1] ?? "";
+  const right = match[2] ?? "";
+  if (left === "") {
+    const suffix = Number(right);
+    if (right === "" || !Number.isSafeInteger(suffix)) return void 0;
+    return suffix === 0 || size <= 0 ? null : { start: Math.max(0, size - suffix), end: size - 1 };
+  }
+  const start = Number(left);
+  const requestedEnd = right === "" ? Number.MAX_SAFE_INTEGER : Number(right);
+  if (!Number.isSafeInteger(start) || !Number.isSafeInteger(requestedEnd) || requestedEnd < start) return void 0;
+  return start >= size ? null : { start, end: Math.min(requestedEnd, size - 1) };
+}
+function mediaHeaders(mimeType, size, range) {
+  const start = range?.start ?? 0;
+  const end = range?.end ?? size - 1;
+  return {
+    "content-type": mimeType,
+    "content-length": Math.max(0, end - start + 1),
+    "cache-control": "private, max-age=60",
+    "accept-ranges": "bytes",
+    ...range === void 0 ? {} : { "content-range": `bytes ${String(start)}-${String(end)}/${String(size)}` },
+    "x-content-type-options": "nosniff"
+  };
+}
+function sendMediaBytes(request, response, bytes, mimeType) {
+  const range = parseByteRange(typeof request.headers.range === "string" ? request.headers.range : void 0, bytes.byteLength);
+  if (range === null) {
+    response.writeHead(416, { "content-range": `bytes */${String(bytes.byteLength)}`, "cache-control": "no-store" });
+    response.end();
+    return;
+  }
+  const start = range?.start ?? 0;
+  const end = range?.end ?? bytes.byteLength - 1;
+  const body = bytes.subarray(start, end + 1);
+  response.writeHead(range === void 0 ? 200 : 206, mediaHeaders(mimeType, bytes.byteLength, range));
+  response.end(request.method === "HEAD" ? void 0 : Buffer.from(body));
+}
+async function hostWorkspaceFile(realm, target2, expectedSize) {
+  const [root, path] = await Promise.all([
+    nodeRealpath(realm.fs.processPath(realm.root)),
+    nodeRealpath(realm.fs.processPath(target2))
+  ]);
+  const inside = relative3(root, path);
+  if (inside === "" || inside.startsWith("..") || isAbsolute3(inside)) return void 0;
+  const local = await nodeStat(path);
+  return local.isFile() && local.size === expectedSize ? path : void 0;
+}
+async function sendWorkspaceMedia(request, response, realm, target2, info, mimeType) {
+  const expectedSize = info.size;
+  if (expectedSize !== void 0) {
+    const processPath = await hostWorkspaceFile(realm, target2, expectedSize).catch(() => void 0);
+    if (processPath !== void 0) {
+      const range = parseByteRange(typeof request.headers.range === "string" ? request.headers.range : void 0, expectedSize);
+      if (range === null) {
+        response.writeHead(416, { "content-range": `bytes */${String(expectedSize)}`, "cache-control": "no-store" });
+        response.end();
+        return;
+      }
+      response.writeHead(range === void 0 ? 200 : 206, mediaHeaders(mimeType, expectedSize, range));
+      if (request.method === "HEAD") {
+        response.end();
+        return;
+      }
+      const stream = createReadStream(processPath, range === void 0 ? void 0 : { start: range.start, end: range.end });
+      request.once("close", () => {
+        if (!response.writableEnded) stream.destroy();
+      });
+      stream.on("error", () => {
+        if (!response.headersSent) response.destroy();
+        else response.end();
+      });
+      stream.pipe(response);
+      return;
+    }
+    if (expectedSize > MEDIA_MAX_BYTES) throw new WorkspaceHttpError(413, "\u8FDC\u7A0B\u5A92\u4F53\u8D85\u8FC7\u5DE5\u4F5C\u53F0\u56DE\u9000\u9884\u89C8\u5927\u5C0F\u9650\u5236\u3002");
+  }
+  sendMediaBytes(request, response, await realm.fs.readBytes(target2, void 0, MEDIA_MAX_BYTES), mimeType);
+}
 async function jsonBody(request, maxBytes) {
   const chunks = [];
   let size = 0;
@@ -560,11 +1156,18 @@ async function jsonBody(request, maxBytes) {
     throw new WorkspaceHttpError(400, "\u8BF7\u6C42\u5FC5\u987B\u662F JSON \u5BF9\u8C61\u3002");
   }
 }
-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");
+function safeRelativePath(path) {
+  return path !== "" && !path.startsWith("/") && !path.includes("\\") && !path.split("/").some((segment) => segment === "" || segment === "." || segment === "..");
+}
+function editablePath(path) {
+  const extensions = path.startsWith(`${GAME_DIRECTORY}/`) ? GAME_EDITABLE_EXTENSIONS : path.startsWith(`${VIDEO_DIRECTORY}/`) ? VIDEO_EDITABLE_EXTENSIONS : EDITABLE_EXTENSIONS;
+  return extensions.has(extname2(path).toLocaleLowerCase());
+}
+function assertCreativePath(path, kind) {
+  if (kind === "text" ? !editablePath(path) : !MEDIA_TYPES.has(extname2(path).toLocaleLowerCase())) {
+    throw new WorkspaceHttpError(415, kind === "text" ? "\u5DE5\u4F5C\u53F0\u4E0D\u652F\u6301\u7F16\u8F91\u8BE5\u6587\u4EF6\u7C7B\u578B\u3002" : "\u76EE\u6807\u4E0D\u662F\u53D7\u652F\u6301\u7684\u77ED\u5267\u5A92\u4F53\u6587\u4EF6\u3002");
   }
-  if (path.startsWith("/") || path.includes("\\") || path.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
+  if (!safeRelativePath(path)) {
     throw new WorkspaceHttpError(403, "\u6587\u4EF6\u8DEF\u5F84\u4E0D\u5728\u521B\u4F5C\u5DE5\u4F5C\u53F0\u4E2D\u3002");
   }
   const root = path.split("/", 1)[0];
@@ -572,9 +1175,11 @@ function assertCreativePath(path) {
     throw new WorkspaceHttpError(403, "\u6587\u4EF6\u8DEF\u5F84\u4E0D\u5728\u521B\u4F5C\u5DE5\u4F5C\u53F0\u4E2D\u3002");
   }
 }
-async function workspaceRealm(context, url) {
-  const rawId = url.searchParams.get("sessionId");
-  if (rawId === null || rawId === "") throw new WorkspaceHttpError(400, "\u7F3A\u5C11 DSH sessionId\u3002");
+function mediaMimeTypeForPath(path) {
+  return MEDIA_TYPES.get(extname2(path).toLocaleLowerCase());
+}
+async function workspaceRealmForSession(context, rawId) {
+  if (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;
@@ -594,8 +1199,13 @@ async function workspaceRealm(context, url) {
   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);
+async function workspaceRealm(context, url) {
+  const rawId = url.searchParams.get("sessionId");
+  if (rawId === null) throw new WorkspaceHttpError(400, "\u7F3A\u5C11 DSH sessionId\u3002");
+  return workspaceRealmForSession(context, rawId);
+}
+async function creativeTarget(realm, path, kind = "text") {
+  assertCreativePath(path, kind);
   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;
@@ -628,11 +1238,15 @@ async function listFiles(realm) {
     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())) {
+      if (entry.type === "directory") {
+        if (!skipVideoDirectory(childPath)) await walk(childPath, entry.target);
+      } else if (entry.type === "file" && (editablePath(childPath) || MEDIA_TYPES.has(extname2(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 });
+        const mimeType = MEDIA_TYPES.get(extname2(entry.name).toLocaleLowerCase());
+        if (version !== void 0 && (!childPath.startsWith(`${VIDEO_DIRECTORY}/`) || visibleVideoPath(childPath))) {
+          files.push({ path: childPath, bytes: entry.size ?? info?.size ?? 0, version, kind: mimeType === void 0 ? "text" : "media", mimeType });
+        }
       }
       if (files.length >= FILE_LIMIT) return;
     }
@@ -647,7 +1261,7 @@ async function listFiles(realm) {
   for (const path of ROOT_FILES) {
     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 });
+    if (info?.type === "file") files.push({ path, bytes: info.size ?? 0, version: info.version, kind: "text" });
   }
   return files.sort((left, right) => left.path.localeCompare(right.path, "zh-Hans-CN"));
 }
@@ -660,6 +1274,276 @@ async function metadata(realm, files, path, maxBytes) {
     return { value: null, error: error instanceof SyntaxError ? `${path} \u4E0D\u662F\u6709\u6548\u7684 JSON\u3002` : `${path} \u6682\u65F6\u65E0\u6CD5\u8BFB\u53D6\u3002` };
   }
 }
+function token(value) {
+  return Buffer.from(value, "utf8").toString("base64url");
+}
+function untoken(value) {
+  try {
+    return Buffer.from(value, "base64url").toString("utf8");
+  } catch {
+    throw new WorkspaceHttpError(400, "\u6E38\u620F\u9884\u89C8\u6807\u8BC6\u65E0\u6548\u3002");
+  }
+}
+function gameRoot(path) {
+  const parts = path.split("/");
+  const name2 = parts[1];
+  return parts.length === 2 && parts[0] === GAME_DIRECTORY && name2 !== void 0 && name2 !== "" && name2 !== "." && name2 !== ".." && name2.length <= 128 && !name2.startsWith(".") && !name2.includes("\\");
+}
+function normalizedVerification(value, binding, verifiedPreviewVersion) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { status: "NOT_RUN", checks: {}, limitations: [], binding };
+  }
+  const record2 = value;
+  const status = record2.status === "PASS" || record2.status === "FAIL" ? record2.status : "NOT_RUN";
+  const rawChecks = typeof record2.checks === "object" && record2.checks !== null && !Array.isArray(record2.checks) ? record2.checks : {};
+  const checks = {};
+  for (const name2 of ["launch", "render", "input", "coreLoop", "outcome", "restart"]) {
+    const check = rawChecks[name2];
+    checks[name2] = check === "PASS" || check === "FAIL" ? check : "NOT_RUN";
+  }
+  const completeRun = typeof record2.completeRun === "object" && record2.completeRun !== null && !Array.isArray(record2.completeRun) ? record2.completeRun : {};
+  const limitations = Array.isArray(record2.limitations) ? record2.limitations.flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return [];
+    const item = entry;
+    return typeof item.scope === "string" && typeof item.reason === "string" ? [{ scope: item.scope, reason: item.reason }] : [];
+  }) : [];
+  return {
+    status,
+    checks,
+    runId: typeof completeRun.id === "string" ? completeRun.id : void 0,
+    limitations,
+    binding,
+    verifiedPreviewVersion
+  };
+}
+async function workspaceText(realm, path, maxBytes) {
+  const target2 = await realm.fs.resolve(path, { cwd: realm.cwd });
+  if (!realm.fs.contains(realm.root, target2) || (await realm.fs.stat(target2))?.type !== "file") return void 0;
+  return (await readVersionedFile(realm.fs, target2, maxBytes)).content;
+}
+async function previewDigest(realm, projectRoot) {
+  const appPath = `${projectRoot}/build/app`;
+  const app = await realm.fs.resolve(appPath, { cwd: realm.cwd });
+  if (!realm.fs.contains(realm.root, app) || (await realm.fs.stat(app))?.type !== "directory") return { ready: false, version: "missing" };
+  const entries = [];
+  let ready = false;
+  const visit = async (directory, path) => {
+    for (const entry of await realm.fs.listDir(directory)) {
+      if (entry.name.startsWith(".") || !realm.fs.contains(app, entry.target)) continue;
+      const childPath = path === "" ? entry.name : `${path}/${entry.name}`;
+      if (entry.type === "directory") await visit(entry.target, childPath);
+      else if (entry.type === "file") {
+        const info = entry.version === void 0 ? await realm.fs.stat(entry.target) : void 0;
+        const version = entry.version ?? info?.version;
+        if (version !== void 0) entries.push(`${childPath}\0${version}`);
+        if (childPath === "index.html") ready = true;
+      }
+      if (entries.length >= 5e3) return;
+    }
+  };
+  await visit(app, "");
+  return { ready, version: createHash("sha256").update(entries.sort().join("\n")).digest("hex").slice(0, 16) };
+}
+function headingTitle(content, fallback) {
+  const heading = content?.split(/\r?\n/u).find((line) => /^#\s+/u.test(line));
+  return heading?.replace(/^#\s+/u, "").replace(/^PRODUCT_BRIEF\s*[·・:]?\s*/iu, "").trim() || fallback;
+}
+async function workspaceGameProjects(realm, files, sessionId, maxBytes) {
+  const roots = [...new Set(files.flatMap((file) => {
+    const parts = file.path.split("/");
+    return parts[0] === GAME_DIRECTORY && parts[1] !== void 0 ? [`${GAME_DIRECTORY}/${parts[1]}`] : [];
+  }))].filter(gameRoot).sort();
+  return Promise.all(roots.map(async (root) => {
+    const id = root.slice(`${GAME_DIRECTORY}/`.length);
+    const qaPath = `${root}/qa/verification.json`;
+    const qaFile = files.find((file) => file.path === qaPath);
+    const [brief, qa, preview] = await Promise.all([
+      workspaceText(realm, `${root}/PRODUCT_BRIEF.md`, maxBytes).catch(() => void 0),
+      workspaceText(realm, qaPath, maxBytes).catch(() => void 0),
+      previewDigest(realm, root).catch(() => ({ ready: false, version: "unavailable" }))
+    ]);
+    let verification;
+    try {
+      verification = qa === void 0 ? void 0 : JSON.parse(qa);
+    } catch {
+      verification = void 0;
+    }
+    const freshness = workspaceVerificationTracker.observe(`${sessionId}\0${root}`, qaFile?.version, preview.version);
+    return {
+      id: `workspace:${id}`,
+      root,
+      title: headingTitle(brief, id),
+      source: "workspace",
+      previewReady: preview.ready,
+      previewUrl: preview.ready ? `/oh-story/game-preview/workspace/${token(sessionId)}/${token(root)}/index.html` : void 0,
+      previewVersion: preview.version,
+      verification: normalizedVerification(verification, freshness.binding, freshness.verifiedPreviewVersion)
+    };
+  }));
+}
+async function workspaceVideoProjects(realm, files, maxBytes) {
+  const roots = [...new Set(files.flatMap((file) => {
+    const root = videoProjectRoot(file.path);
+    return root === void 0 ? [] : [root];
+  }))].sort((left, right) => left.localeCompare(right, "zh-Hans-CN"));
+  return Promise.all(roots.map(async (root) => {
+    const findPath = (name2) => files.find((file) => file.path.startsWith(`${root}/`) && file.path.split("/").at(-1) === name2)?.path;
+    const readJson = async (name2) => {
+      const path = findPath(name2);
+      if (path === void 0) return void 0;
+      const content = await workspaceText(realm, path, maxBytes).catch(() => void 0);
+      if (content === void 0) return void 0;
+      try {
+        return JSON.parse(content);
+      } catch {
+        return void 0;
+      }
+    };
+    const [project, runManifest, assembly] = await Promise.all([
+      readJson("project.json"),
+      readJson("recap_run_manifest.json"),
+      readJson("assembly_manifest.json")
+    ]);
+    return summarizeVideoProject(root, files, { project, runManifest, assembly });
+  }));
+}
+function bundledExampleRoot() {
+  return resolve4(defaultNovelToGameSkillRoot(), `../examples/${BUNDLED_GAME_EXAMPLE}`);
+}
+async function bundledGameExample() {
+  const root = bundledExampleRoot();
+  const [example, verification, manifest] = await Promise.all([
+    readNodeFile(resolve4(root, "example.json"), "utf8"),
+    readNodeFile(resolve4(root, "qa/verification.json"), "utf8"),
+    readNodeFile(resolve4(defaultNovelToGameSkillRoot(), "../manifest.json"), "utf8")
+  ]);
+  const exampleJson = JSON.parse(example);
+  const manifestJson = JSON.parse(manifest);
+  const previewVersion = typeof manifestJson.upstream?.commit === "string" ? manifestJson.upstream.commit.slice(0, 16) : "bundled";
+  return {
+    id: `example:${BUNDLED_GAME_EXAMPLE}`,
+    root: `examples/${BUNDLED_GAME_EXAMPLE}`,
+    title: typeof exampleJson.title === "string" ? exampleJson.title : "\u91D1\u74F6\u6885 \xB7 \u98CE\u6708\u603B\u8D26",
+    source: "example",
+    previewReady: true,
+    previewUrl: `/oh-story/game-preview/example/${BUNDLED_GAME_EXAMPLE}/index.html`,
+    previewVersion,
+    verification: normalizedVerification(JSON.parse(verification), "PINNED", previewVersion)
+  };
+}
+function previewContentType(path) {
+  switch (extname2(path).toLocaleLowerCase()) {
+    case ".html":
+      return "text/html; charset=utf-8";
+    case ".css":
+      return "text/css; charset=utf-8";
+    case ".js":
+    case ".mjs":
+      return "text/javascript; charset=utf-8";
+    case ".json":
+      return "application/json; charset=utf-8";
+    case ".svg":
+      return "image/svg+xml";
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".gif":
+      return "image/gif";
+    case ".woff":
+      return "font/woff";
+    case ".woff2":
+      return "font/woff2";
+    case ".wasm":
+      return "application/wasm";
+    case ".mp3":
+      return "audio/mpeg";
+    case ".ogg":
+      return "audio/ogg";
+    default:
+      return "application/octet-stream";
+  }
+}
+function previewAssetSources(request) {
+  const authority = request.headers.host;
+  if (authority === void 0) return "'none'";
+  const prefix = `${authority}/oh-story/game-preview/`;
+  return `http://${prefix} https://${prefix}`;
+}
+function previewContentSecurityPolicy(assets) {
+  return [
+    "sandbox allow-scripts allow-forms allow-modals allow-downloads allow-same-origin",
+    "default-src 'none'",
+    `script-src 'unsafe-inline' 'wasm-unsafe-eval' blob: ${assets}`,
+    `style-src 'unsafe-inline' ${assets}`,
+    `img-src data: blob: ${assets}`,
+    `media-src data: blob: ${assets}`,
+    `font-src data: ${assets}`,
+    `connect-src ${assets}`,
+    `worker-src blob: ${assets}`,
+    `manifest-src ${assets}`,
+    "object-src 'none'",
+    "base-uri 'none'",
+    "form-action 'none'",
+    "frame-ancestors 'self' http://127.0.0.1:* http://localhost:*"
+  ].join("; ");
+}
+function sendPreview(request, response, path, bytes) {
+  const assets = previewAssetSources(request);
+  response.writeHead(200, {
+    "content-type": previewContentType(path),
+    "content-length": bytes.byteLength,
+    "cache-control": "no-store",
+    "x-content-type-options": "nosniff",
+    "cross-origin-resource-policy": "cross-origin",
+    "access-control-allow-origin": "*",
+    "content-security-policy": previewContentSecurityPolicy(assets)
+  });
+  response.end(bytes);
+}
+async function previewBytes(context, pathname) {
+  let segments;
+  try {
+    segments = pathname.split("/").slice(3).map((segment) => decodeURIComponent(segment));
+  } catch {
+    throw new WorkspaceHttpError(400, "\u6E38\u620F\u9884\u89C8\u5730\u5740\u65E0\u6548\u3002");
+  }
+  const kind = segments.shift();
+  if (kind === "example") {
+    const id = segments.shift();
+    const path = segments.join("/") || "index.html";
+    if (id !== BUNDLED_GAME_EXAMPLE || !safeRelativePath(path)) throw new WorkspaceHttpError(404, "\u6E38\u620F\u793A\u4F8B\u4E0D\u5B58\u5728\u3002");
+    const appRoot = resolve4(bundledExampleRoot(), "build/app");
+    const target2 = resolve4(appRoot, path);
+    const escaped = relative3(appRoot, target2);
+    if (escaped.startsWith("..") || isAbsolute3(escaped)) throw new WorkspaceHttpError(403, "\u9884\u89C8\u8D44\u6E90\u79BB\u5F00\u4E86\u6E38\u620F\u76EE\u5F55\u3002");
+    const info = await nodeStat(target2).catch(() => void 0);
+    if (!info?.isFile()) throw new WorkspaceHttpError(404, "\u9884\u89C8\u8D44\u6E90\u4E0D\u5B58\u5728\u3002");
+    if (info.size > PREVIEW_FILE_LIMIT) throw new WorkspaceHttpError(413, "\u9884\u89C8\u8D44\u6E90\u8FC7\u5927\u3002");
+    return { path, bytes: await readNodeFile(target2) };
+  }
+  if (kind === "workspace") {
+    const session = segments.shift();
+    const project = segments.shift();
+    const path = segments.join("/") || "index.html";
+    if (session === void 0 || project === void 0 || !safeRelativePath(path)) throw new WorkspaceHttpError(400, "\u6E38\u620F\u9884\u89C8\u5730\u5740\u65E0\u6548\u3002");
+    const realm = await workspaceRealmForSession(context, untoken(session));
+    const root = untoken(project);
+    if (!gameRoot(root)) throw new WorkspaceHttpError(403, "\u6E38\u620F\u9879\u76EE\u8DEF\u5F84\u65E0\u6548\u3002");
+    const appRoot = await realm.fs.resolve(`${root}/build/app`, { cwd: realm.cwd });
+    const target2 = await realm.fs.resolve(`${root}/build/app/${path}`, { cwd: realm.cwd });
+    if (!realm.fs.contains(realm.root, appRoot) || !realm.fs.contains(appRoot, target2)) {
+      throw new WorkspaceHttpError(403, "\u9884\u89C8\u8D44\u6E90\u79BB\u5F00\u4E86\u6E38\u620F\u76EE\u5F55\u3002");
+    }
+    const info = requireRegularFile(await realm.fs.stat(target2));
+    if (info.size !== void 0 && info.size > PREVIEW_FILE_LIMIT) throw new WorkspaceHttpError(413, "\u9884\u89C8\u8D44\u6E90\u8FC7\u5927\u3002");
+    return { path, bytes: await realm.fs.readBytes(target2, void 0, PREVIEW_FILE_LIMIT) };
+  }
+  throw new WorkspaceHttpError(404, "\u6E38\u620F\u9884\u89C8\u4E0D\u5B58\u5728\u3002");
+}
 function mapFsError(error) {
   if (!(error instanceof FsError)) return void 0;
   switch (error.code) {
@@ -684,15 +1568,33 @@ function mapFsError(error) {
 }
 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");
     const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    const gamePreview = url.pathname.startsWith("/oh-story/game-preview/");
+    const trusted = gamePreview ? isTrustedPreviewNavigation(request, options.trustedHosts ?? []) : isTrustedWorkspaceRequest(request, options.trustedHosts ?? []);
+    if (!trusted) throw new WorkspaceHttpError(403, "\u8BF7\u6C42\u6765\u6E90\u4E0D\u53D7\u4FE1\u4EFB\u3002");
+    if (gamePreview && request.method === "GET") {
+      const preview = await previewBytes(context, url.pathname);
+      sendPreview(request, response, preview.path, preview.bytes);
+      return;
+    }
     if (url.pathname === "/oh-story/workspace" && request.method === "GET") {
       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" });
+      const sessionId = url.searchParams.get("sessionId");
+      if (sessionId === null) throw new WorkspaceHttpError(400, "\u7F3A\u5C11 DSH sessionId\u3002");
+      const games = [
+        ...await workspaceGameProjects(realm, files, sessionId, options.maxBytes),
+        await bundledGameExample()
+      ];
+      const videos = await workspaceVideoProjects(realm, files, options.maxBytes);
+      send(response, 200, { cwd: realm.cwd, files, games, videos, tracking: tracking.value, shortDrama: shortDrama.value, metadataErrors, mode: "dsh-session" });
+      return;
+    }
+    if (url.pathname === "/oh-story/video-preflight" && request.method === "GET") {
+      send(response, 200, await videoPreflight());
       return;
     }
     if (url.pathname === "/oh-story/file" && request.method === "GET") {
@@ -703,6 +1605,17 @@ async function handle(context, request, response, options) {
       send(response, 200, { path, ...file });
       return;
     }
+    if (url.pathname === "/oh-story/media" && (request.method === "GET" || request.method === "HEAD")) {
+      const realm = await workspaceRealm(context, url);
+      const path = url.searchParams.get("path");
+      if (path === null) throw new WorkspaceHttpError(400, "\u7F3A\u5C11\u5A92\u4F53\u6587\u4EF6\u8DEF\u5F84\u3002");
+      const mimeType = mediaMimeTypeForPath(path);
+      if (mimeType === void 0) throw new WorkspaceHttpError(415, "\u76EE\u6807\u4E0D\u662F\u53D7\u652F\u6301\u7684\u77ED\u5267\u5A92\u4F53\u6587\u4EF6\u3002");
+      const target2 = await creativeTarget(realm, path, "media");
+      const info = requireRegularFile(await realm.fs.stat(target2));
+      await sendWorkspaceMedia(request, response, realm, target2, info, mimeType);
+      return;
+    }
     if (url.pathname === "/oh-story/file" && request.method === "PUT") {
       const realm = await workspaceRealm(context, url);
       const path = url.searchParams.get("path");
@@ -748,27 +1661,39 @@ async function apply(context, config = {}) {
   for (const entry of trustedHosts) assertTrustedWorkspaceAuthority(entry);
   context.skills.registerProvider(() => createOhStorySkillProvider());
   context.skills.registerProvider(() => createDramaSkillProvider());
+  context.skills.registerProvider(() => createNovelToGameSkillProvider());
+  context.skills.registerProvider(() => createVideoRecapSkillProvider());
   registerOhStoryHooks(context);
+  registerOhStoryProductionTool(context);
   await registerOhStoryRoleTool(context);
   registerWorkspaceRoute(context, { maxBytes: config.editorMaxBytes ?? 2097152, trustedHosts });
 }
 var index_default = { name, inject, Config, apply };
 export {
   Config,
+  OH_STORY_PRODUCTION_TOOL_NAME,
+  OH_STORY_REFERENCE_TOOL_NAME,
   OH_STORY_ROLE_NAMES,
   OH_STORY_ROLE_TOOL_NAME,
   apply,
+  bundledReferenceGuard,
   createDramaSkillProvider,
+  createNovelToGameSkillProvider,
+  createOhStoryProductionTool,
+  createOhStoryReferenceTool,
   createOhStoryRoleTool,
   createOhStorySkillProvider,
+  createVideoRecapSkillProvider,
   index_default as default,
   inject,
   loadBundledRole,
   name,
   parseBundledSkill,
   registerOhStoryHooks,
+  registerOhStoryProductionTool,
   registerOhStoryRoleTool,
   registerWorkspaceRoute,
-  roleToolFilter
+  roleToolFilter,
+  validateProductionIntent
 };
 //# sourceMappingURL=index.js.map