dsh-doc-assistant 0.1.14 → 0.1.18

package/src/client/70-shelf.js

@@ -378,7 +378,13 @@ __define('./shelf', (module, exports, require) => {
     const p = props || {};
     const cover = normalizeCover(p.cover, p.relPath, p.format);
     const [failed, setFailed] = React.useState(false);
+    const [loaded, setLoaded] = React.useState(false);
     const [naturalShape, setNaturalShape] = React.useState(null);
+    React.useEffect(() => {
+      setFailed(false);
+      setLoaded(false);
+      setNaturalShape(null);
+    }, [cover.imageUrl, cover.relPath]);
     // 形状优先级：父级/显式给的 > 图片实际尺寸测出来的 > 按 cover.width/height 推断 > 竖版。
     // 即使图片失败回落生成封面也保持同一卡片形状，避免书架在 <img> 出错时跳版（§17.3.1）。
     const controlled = p.shape && p.shape.key ? p.shape : null;
@@ -396,6 +402,7 @@ __define('./shelf', (module, exports, require) => {
         setFailed(true);
         return;
       }
+      setLoaded(true);
       const next = shapeFor({ width: w, height: hgt });
       if (next.key === shape.key) return;
       if (controlled) {
@@ -413,10 +420,13 @@ __define('./shelf', (module, exports, require) => {
         'data-cover-kind': 'page',
         'data-cover-shape': shape.key,
         'data-cover-src': cover.imageUrl,
+        'aria-busy': !loaded,
       }, [
+        !loaded ? h(CoverArt, { key: 'placeholder', cover, shape, size: width,
+          className: P + 'CoverPlaceholder', relPath: cover.relPath, format: cover.format }) : null,
         h('img', {
           key: 'img',
-          className: P + 'CoverImg',
+          className: cx(P + 'CoverImg', !loaded && P + 'CoverImgLoading'),
           src: cover.imageUrl,
           alt: cover.title,
           loading: 'lazy',
@@ -1079,8 +1089,10 @@ __define('./shelf', (module, exports, require) => {
 .${P}Book_landscape .${P}Cover{box-shadow:0 6px 18px rgba(0,0,0,.28)}
 .${P}Book_square .${P}Cover{border-radius:8px}
 .${P}CoverPage{background:var(--dsw-alias-bg-layer-2)}
-.${P}CoverImg{display:block;width:100%;height:100%;object-fit:cover;object-position:top center;
+.${P}CoverPlaceholder{position:absolute;inset:0;box-shadow:none}
+.${P}CoverImg{position:absolute;inset:0;display:block;width:100%;height:100%;object-fit:cover;object-position:top center;
   background:var(--dsw-alias-bg-layer-2)}
+.${P}CoverImgLoading{opacity:0}
 .${P}PageFade{position:absolute;left:0;right:0;bottom:0;height:26%;pointer-events:none;
   background:linear-gradient(to top,rgba(0,0,0,.28),rgba(0,0,0,0))}
 .${P}PageBadge{position:absolute;left:8px;bottom:8px;background:rgba(0,0,0,.42);color:#fff;

package/src/host/chat.js

@@ -42,7 +42,12 @@ import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 
 import { resolveRoute, safeArray, fromChatReply } from './revise.js';
+import { rebaseRevisionSelection } from './revisionRebase.js';
 import { expansionPlan, expansionPrompt } from './expansion.js';
+import { loadVisualContext, visualEvidence, visualImageParts } from './visualContext.js';
+import { revisionBoundaryPrompt } from './revisionBoundary.js';
+import { resolveWordSelection } from './wordSelection.js';
+import { service as modelService } from './modelVision.js';
 
 /** Request-body cap, matching host-core's dispatcher. */
 const BODY_LIMIT = 512 * 1024;
@@ -75,6 +80,7 @@ const EDIT_PREAMBLE = [
   '理解、分析、评价、建议、翻译、比较，以及仅要求总结、概括、提炼要点、尚未要求替换原文的请求，intent 必须为 answer，只回答，不生成修订。仅询问修改是否有必要或是否可行也属于咨询。',
   '用户明确要求执行修改、重写、增删、调整语气或结构、按个人要求修改，或对上一份待接受修订提出进一步修改时，intent 为 revise。礼貌表达“能不能帮我改得简短一点”也是执行修改的请求，不要误判为咨询。',
   '修改范围只能是当前引用的原文。revised 必须是该选区修改后的完整文本，不能省掉未改的部分或包含选区外的上下文。',
+  'revised 必须遵守选区末尾边界：原文没有选入句末标点，结果不得在结尾补上句末标点。此限制只针对写回的 revised，不限制 reply 中正常回答的标点。',
   '用户明确提供的新事实、名称、数字可以按要求修改；除此之外不要编造事实。',
   '这是生成待接受的修订，不是写回文件，不能声称已经修改了文档。',
   '存在上轮待接受修订时，进一步修改以它为草稿，但仍返回当前引用位置的完整最终文本。',
@@ -501,12 +507,12 @@ async function loadDocText(deps, projectId, relPath) {
     return { text: raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw, format, reason: '', hash: info.hash };
   }
 
-  const doc = await docir.parse(abs, info);
+  const doc = await docir.parse(abs, info, { home: deps.config?.home });
   const blocks = Array.isArray(doc?.blocks) ? doc.blocks : [];
-  const text = ['docx', 'xlsx', 'pptx'].includes(format)
+  const text = ['doc', 'docx', 'xlsx', 'pptx'].includes(format)
     ? (await import('./office.js')).plainSource(doc)
     : blocks.map(b => String(b?.text ?? '')).filter(Boolean).join('\n\n');
-  return { text, format, parsed: doc, hash: info.hash, reason: String(doc?.meta?.reason ?? info?.reason ?? '') };
+  return { text, format, abs, parsed: doc, hash: info.hash, reason: String(doc?.meta?.reason ?? info?.reason ?? '') };
 }
 
 /**
@@ -534,7 +540,7 @@ export function buildContext(deps, input) {
     );
   } else if (docText.length <= sizes.docChars) {
     mode = 'full';
-    lines.push('', '文档完整内容如下：', '<<<DOCUMENT', docText, 'DOCUMENT>>>');
+    lines.push('', input.visual ? '文档逐页内容索引与相关页面证据如下：' : '文档完整内容如下：', '<<<DOCUMENT', docText, 'DOCUMENT>>>');
   } else {
     mode = 'excerpt';
     const span = excerptSpan(docText, anchor, sizes.contextChars);
@@ -750,6 +756,7 @@ export async function listChatModels(deps) {
     for (const model of choices.slice(0, 300)) if (typeof model?.id === 'string') models.push({
       provider: provider.id, model: model.id, label: typeof model.name === 'string' ? model.name : typeof model.label === 'string' ? model.label : model.id,
       providerLabel: typeof provider.name === 'string' ? provider.name : typeof provider.label === 'string' ? provider.label : provider.id,
+      ...(Array.isArray(model.inputModalities) ? { inputModalities: model.inputModalities.filter(item => item === 'text' || item === 'image') } : {}),
     });
   }
   const current = await resolveRoute(deps.ctx, deps, {});
@@ -858,24 +865,45 @@ async function handleSend(deps, body) {
   let revision;
   try {
     const doc = await loadDocText(deps, target.projectId, target.relPath);
+    const route = chosenRoute || await resolveRoute(deps.ctx, deps, {});
+    const visual = doc.abs ? await loadVisualContext(deps, { abs: doc.abs, doc, route }) : null;
     const editFromQuote = body?.editFromQuote === true && Boolean(quote);
     let blocked = '';
     if (editFromQuote) {
       if (target.readOnly) blocked = '文档所在根目录是只读的';
-      else if (!deps.writers?.canWrite?.(doc.format)) blocked = '当前文档格式无法写回修订';
-      else if (expectedHash && expectedHash !== doc.hash) blocked = '文档在引用后已变化，请重新引用原文';
-      else if (!anchor) blocked = '引用缺少原文位置，请重新引用';
-      else if (anchor.kind === 'cell') {
+      else if (!deps.writers?.canWrite?.(doc.format)) blocked = doc.format === 'doc' ? '旧版 DOC 需要先点击“转换并编辑”，在 DOCX 副本上生成修订' : '当前文档格式无法写回修订';
+      if (!blocked && expectedHash && expectedHash !== doc.hash) {
+        try {
+          const current = await rebaseRevisionSelection(deps, {
+            project: await deps.projects.get(target.projectId), path: target.relPath, abs: target.abs,
+            fromHash: expectedHash, toHash: doc.hash, anchor, original: quote, format: doc.format,
+          });
+          anchor = current.anchor;
+          expectedHash = current.docHash;
+          userMessage.anchor = anchor;
+          userMessage.documentHash = expectedHash;
+        } catch (error) { blocked = error.message || '文档在引用后已变化，请重新引用原文'; }
+      }
+      if (!blocked && !anchor) blocked = '引用缺少原文位置，请重新引用';
+      else if (!blocked && anchor.kind === 'cell') {
         const { cellText } = await import('./office.js');
         if (doc.format !== 'xlsx' || cellText(doc.parsed, anchor.sheet, anchor.cell) !== quote) blocked = '引用对不上单元格中的完整原文，请重新引用';
-      } else if (!Number.isInteger(anchor.srcStart) || !Number.isInteger(anchor.srcEnd)
+      } else if (!blocked && doc.format === 'docx' && Array.isArray(anchor.segments)) {
+        try {
+          const selection = resolveWordSelection(doc.parsed, anchor);
+          if (selection.original !== quote) blocked = '引用对不上文档里的完整原文，请重新引用';
+          else { anchor = selection.anchor; userMessage.anchor = anchor; }
+        } catch (error) { blocked = error.message || '引用选区无法定位，请重新引用完整段落'; }
+      } else if (!blocked && (!Number.isInteger(anchor.srcStart) || !Number.isInteger(anchor.srcEnd)
         || anchor.srcStart < 0 || anchor.srcEnd <= anchor.srcStart || anchor.srcEnd > doc.text.length
-        || doc.text.slice(anchor.srcStart, anchor.srcEnd) !== quote) blocked = '引用对不上文档里的完整原文，请重新引用';
+        || doc.text.slice(anchor.srcStart, anchor.srcEnd) !== quote)) blocked = '引用对不上文档里的完整原文，请重新引用';
       if (!expectedHash) userMessage.documentHash = doc.hash;
     }
+    const visualText = visual ? visualEvidence(visual, message, sizes.docChars) : '';
     const context = buildContext(deps, {
       relPath: target.relPath,
-      docText: doc.text,
+      docText: visual ? visualText : doc.text,
+      visual: Boolean(visual),
       format: doc.format,
       reason: doc.reason,
       anchor,
@@ -890,10 +918,11 @@ async function handleSend(deps, body) {
     // `toLlmMessages`, which skips failed/empty assistant records.
     const llmMessages = [
       ...toLlmMessages(history, sizes.turns),
-      { role: 'user', content: [{ type: 'text', text: context.userContent }] },
+      { role: 'user', content: [{ type: 'text', text: context.userContent }, ...(visual ? visualImageParts(visual, message, modelService(deps, 'attachments')?.imageLimits) : [])] },
     ];
     let styleGuidance = '';
     if (editFromQuote && !blocked) {
+      styleGuidance += `\n${revisionBoundaryPrompt(quote)}`;
       const settings = deps.config?.settings || {};
       const preset = settings.stylePresets?.find(item => item.id === settings.defaultStyleId);
       if (preset) styleGuidance += `\n仅当用户要求润色或扩写时，默认文风为：${preset.prompt}。用户明确的文风要求优先。`;
@@ -904,7 +933,7 @@ async function handleSend(deps, body) {
       system: editFromQuote ? `${context.system}\n\n${EDIT_PREAMBLE}\n${blocked ? `当前不能生成修订：${blocked}。无论用户如何要求，intent 只能为 answer；如要求修改，请说明原因。` : '当前引用已核对，可根据用户明确的修改要求生成修订。'}${styleGuidance}` : context.system,
       messages: llmMessages,
       editFromQuote,
-      route: chosenRoute,
+      route,
       // `/chat/send` is non-streaming in M1.1, so there is no client-side
       // cancellation channel yet; the host still passes a signal because the
       // llm runtime requires one.
@@ -933,6 +962,7 @@ async function handleSend(deps, body) {
       provider: reply.provider,
       model: reply.model,
       ...(reply.completion ? { completion: reply.completion } : {}),
+      ...(visual ? { documentContext: { source: visual.source, pagesRead: visual.pages.length, totalPages: visual.total, complete: visual.complete } } : {}),
       ...(revision?.id ? { revisionId: revision.id, revisionText: revision.revised } : {}),
     };
   } catch (error) {

package/src/host/covers.js

@@ -41,6 +41,7 @@ import { basename, dirname, extname, join } from 'node:path';
 import { deflateSync } from 'node:zlib';
 
 import { firstPagePng, WORD_PREVIEW_VERSION } from './convert.js';
+import { embeddedPptxCover, PPTX_COVER_VERSION } from './officeImages.js';
 import { resolveRoute } from './revise.js';
 // Host-core's own skip rule, imported rather than re-implemented: `/covers` and
 // `/tree` must agree on what a "document" is, and two copies of that rule would
@@ -324,7 +325,7 @@ export function paletteIsReadable(palette) {
 // ---------------------------------------------------------------------------
 
 /** Formats whose first page *is* the cover. */
-const PAGE_FORMATS = new Set(['image', 'pdf', 'docx', 'pptx', 'xlsx']);
+const PAGE_FORMATS = new Set(['image', 'pdf', 'doc', 'docx', 'pptx', 'xlsx']);
 
 /** Raster types a browser renders directly, so we can serve the file itself. */
 const DIRECT_IMAGE_MIME = new Map([
@@ -350,8 +351,9 @@ export function artFor(format) {
 }
 
 /** URL a client can put straight into `<img src>`. */
-export function coverImageUrl(projectId, relPath) {
+export function coverImageUrl(projectId, relPath, version) {
   const q = new URLSearchParams({ projectId: String(projectId), path: normalizeRelPath(relPath) });
+  if (typeof version === 'string' && version) q.set('v', version);
   return `/doc-assistant/cover/image?${q.toString()}`;
 }
 
@@ -389,6 +391,7 @@ const CANONICAL_PAGE = {
   pptx: { width: 1600, height: 900 },
   // A4 at ~110 dpi (matches a measured 910x1287 page)
   docx: { width: 1240, height: 1754 },
+  doc: { width: 1240, height: 1754 },
   // Spreadsheets are **portrait A4** here, not the landscape 4:3 one might
   // assume from "tables are usually wide". Measured on all four of the user's
   // real `.xlsx` files: 935x1210, 910x1287, 935x1210, 910x1287 — 4/4 portrait,
@@ -572,6 +575,10 @@ export async function estimatePageSize(abs, format, relPath) {
 
 const renderChain = { tail: Promise.resolve() };
 const renderInflight = new Map();
+// Reading an already embedded slide image does not spawn Office and must not
+// wait behind another document's conversion. Coalesce its cache writes alone.
+const embeddedCoverInflight = new Map();
+const embeddedCoverStats = { started: 0, coalesced: 0 };
 // `running` is incremented when a task actually *starts*, not when it is
 // queued. Counting at enqueue time makes `peak` report queue depth, which would
 // read as "5 concurrent renders" for five queued tasks — a statistic that lies
@@ -616,7 +623,8 @@ function renderOnce(key, task) {
 
 /** Observable queue state, for tests and diagnostics. */
 export function renderQueueStats() {
-  return { ...renderStats, inflight: renderInflight.size, chainDepth: renderStats.queued - renderStats.completed };
+  return { ...renderStats, inflight: renderInflight.size, chainDepth: renderStats.queued - renderStats.completed,
+    embedded: { ...embeddedCoverStats, inflight: embeddedCoverInflight.size } };
 }
 
 /** Reset the counters (tests only; does not cancel queued work). */
@@ -626,6 +634,8 @@ export function resetRenderStats() {
   renderStats.queued = 0;
   renderStats.completed = 0;
   renderStats.coalesced = 0;
+  embeddedCoverStats.started = 0;
+  embeddedCoverStats.coalesced = 0;
 }
 
 // ---------------------------------------------------------------------------
@@ -1090,11 +1100,12 @@ function coverFromCache(cached, base) {
 }
 
 /**
- * Absolute path of one document's cached **page** PNG
+ * Absolute path of one document's cached **page** image
  * (`covers/<projectId>/<sha256(relPath)[:16]>.png`).
  *
- * The `.json` sibling next to it holds the `docHash` that decides freshness —
- * the PNG cannot store its own provenance, and re-deriving it from the file
+ * The historical `.png` filename is retained for cache compatibility; the
+ * metadata records MIME because an embedded PPTX cover may be a JPEG. The
+ * `.json` sibling holds the `docHash` that decides freshness, and re-deriving it from the file
  * every time would defeat the cache.
  *
  * @param {object} deps
@@ -1128,7 +1139,8 @@ async function readCachedPagePng(deps, projectId, relPath, docHash) {
   if (typeof meta.docHash !== 'string' || meta.docHash !== docHash) return null;
   try {
     const bytes = await readFile(coverImageFileFor(deps, projectId, relPath));
-    return bytes.length > 0 ? { bytes, meta } : null;
+    const mime = meta.mime === 'image/jpeg' ? 'image/jpeg' : 'image/png';
+    return bytes.length > 0 ? { bytes, meta, mime } : null;
   } catch {
     return null;
   }
@@ -1138,12 +1150,12 @@ async function readCachedPagePng(deps, projectId, relPath, docHash) {
 async function writeCachedPagePng(deps, projectId, relPath, docHash, bytes, info) {
   const pngFile = coverImageFileFor(deps, projectId, relPath);
   await mkdir(dirname(pngFile), { recursive: true, mode: 0o700 });
-  const tmpPng = `${pngFile}.tmp`;
+  const tmpPng = `${pngFile}.${randomUUID()}.tmp`;
   await writeFile(tmpPng, bytes, { mode: 0o600 });
   await rename(tmpPng, pngFile);
 
   const metaFile = coverImageMetaFor(deps, projectId, relPath);
-  const tmpMeta = `${metaFile}.tmp`;
+  const tmpMeta = `${metaFile}.${randomUUID()}.tmp`;
   await writeFile(
     tmpMeta,
     JSON.stringify(
@@ -1513,7 +1525,11 @@ async function handleCoversBatch(deps, url) {
         // `/cover/image`, and only for the cards it actually shows. Resolving
         // the absolute path is cheap (no file read) and lets `pageCover` probe
         // the real page size from the file header.
-        covers.push(await pageCover(deps, projectId, entry.relPath, format, docChars, abs));
+        // Let the browser keep covers cached, but use a different URL after a
+        // saved file changes so its five-minute HTTP cache cannot hide updates.
+        const imageVersion = `${entry.mtime ?? ''}:${entry.size ?? ''}:${format === 'pptx'
+          ? PPTX_COVER_VERSION : format === 'docx' ? WORD_PREVIEW_VERSION : 'page-cover-v1'}`;
+        covers.push(await pageCover(deps, projectId, entry.relPath, format, docChars, abs, imageVersion));
         continue;
       }
       covers.push(await coverWithoutModel(deps, projectId, entry.relPath, { format, docChars }));
@@ -1585,7 +1601,7 @@ async function handleGenerate(deps, body) {
  *
  * @returns {object} Cover
  */
-async function pageCover(deps, projectId, relPath, format, docChars, abs = null) {
+async function pageCover(deps, projectId, relPath, format, docChars, abs = null, imageVersion) {
   const base = heuristicCover({ relPath, format });
   void docChars;
 
@@ -1625,7 +1641,7 @@ async function pageCover(deps, projectId, relPath, format, docChars, abs = null)
     source: 'rendered',
     art: 'page',
     // §17.3: only present when the document has a page to show.
-    imageUrl: coverImageUrl(projectId, relPath),
+    imageUrl: coverImageUrl(projectId, relPath, imageVersion),
   };
 }
 
@@ -1668,20 +1684,42 @@ async function pagePng(deps, projectId, relPath, abs, format, docHash) {
   // behind a render would mean a cached card waits ~8 s for an unrelated deck to
   // finish converting — the shelf would appear to load in dribs and drabs even
   // though every image was already on disk.
-  const renderHash = format === 'docx' ? `${docHash}:${WORD_PREVIEW_VERSION}` : docHash;
+  const renderHash = format === 'docx' ? `${docHash}:${WORD_PREVIEW_VERSION}`
+    : format === 'pptx' ? `${docHash}:${PPTX_COVER_VERSION}` : docHash;
   const hit = await readCachedPagePng(deps, projectId, relPath, renderHash);
   if (hit !== null) {
-    return { bytes: hit.bytes, mime: 'image/png', cached: true, ms: Date.now() - started };
+    return { bytes: hit.bytes, mime: hit.mime, cached: true, ms: Date.now() - started, source: hit.meta.source };
   }
 
   const key = `${projectId}\u0000${normalizeRelPath(relPath)}`;
+  if (format === 'pptx') {
+    const embeddedKey = `${key}\u0000${renderHash}`;
+    let pending = embeddedCoverInflight.get(embeddedKey);
+    if (!pending) {
+      embeddedCoverStats.started += 1;
+      pending = (async () => {
+        const image = await embeddedPptxCover(abs);
+        if (!image) return null;
+        await writeCachedPagePng(deps, projectId, relPath, renderHash, image.bytes, {
+          width: image.width, height: image.height, mime: image.mime,
+          converted: false, source: image.source, renderMs: Date.now() - started,
+        });
+        return { bytes: image.bytes, mime: image.mime, source: image.source, cached: false, ms: Date.now() - started };
+      })().finally(() => embeddedCoverInflight.delete(embeddedKey));
+      embeddedCoverInflight.set(embeddedKey, pending);
+    } else {
+      embeddedCoverStats.coalesced += 1;
+    }
+    const image = await pending;
+    if (image) return image;
+  }
   return renderOnce(key, async () => {
     // Re-check inside the queue: a request that queued a moment ago may have
     // just rendered exactly this document, and `renderOnce` coalesces only
     // *concurrent* callers, not ones that arrive one tick later.
     const late = await readCachedPagePng(deps, projectId, relPath, renderHash);
     if (late !== null) {
-      return { bytes: late.bytes, mime: 'image/png', cached: true, ms: Date.now() - started };
+      return { bytes: late.bytes, mime: late.mime, cached: true, ms: Date.now() - started, source: late.meta.source };
     }
     const rendered = await firstPagePng(abs);
     await writeCachedPagePng(deps, projectId, relPath, renderHash, rendered.bytes, {
@@ -1689,6 +1727,8 @@ async function pagePng(deps, projectId, relPath, abs, format, docHash) {
       height: rendered.height,
       converted: rendered.converted,
       renderMs: rendered.ms,
+      mime: 'image/png',
+      source: 'rendered-page',
     });
     return { bytes: rendered.bytes, mime: 'image/png', cached: false, ms: Date.now() - started };
   });
@@ -1730,6 +1770,7 @@ async function handleCoverImage(deps, url, req, res) {
       'x-cover-cached': out.cached ? '1' : '0',
       'x-cover-art': artFor(format),
       'x-cover-ms': String(out.ms),
+      'x-cover-source': out.source ?? 'rendered-page',
     });
   } catch {
     // Never a 5xx and never JSON: one unrenderable document must not turn into

package/src/host/docir.js

@@ -61,6 +61,7 @@ const BY_EXT = new Map(
       '.js', '.ts', '.tsx', '.jsx', '.json', '.yaml', '.yml', '.py', '.go', '.rs',
       '.java', '.c', '.h', '.cpp', '.css', '.scss', '.sh', '.sql', '.toml', '.ini',
     ],
+    doc: ['.doc'],
     docx: ['.docx'],
     xlsx: ['.xlsx'],
     csv: ['.csv'],
@@ -74,13 +75,13 @@ const BY_EXT = new Map(
         format,
         renderable: true,
         // CONTRACT §4: pdf and image are render-only; everything else writes.
-        writable: format !== 'pdf' && format !== 'image',
+        writable: format !== 'pdf' && format !== 'image' && format !== 'doc',
         granularity:
           format === 'xlsx' || format === 'csv'
             ? 'cell'
             : format === 'pptx'
               ? 'shape'
-              : format === 'pdf' || format === 'image'
+              : format === 'pdf' || format === 'image' || format === 'doc'
                 ? null
                 : 'range',
       },
@@ -116,7 +117,7 @@ const OFFICE_MAX_BYTES = 40_000_000;
  * @returns {number}
  */
 export function sizeLimit(format, maxFileBytes = DEFAULT_MAX_BYTES) {
-  if (format === 'docx' || format === 'xlsx' || format === 'pptx' || format === 'pdf' || format === 'image') {
+  if (format === 'doc' || format === 'docx' || format === 'xlsx' || format === 'pptx' || format === 'pdf' || format === 'image') {
     return Math.max(maxFileBytes, OFFICE_MAX_BYTES);
   }
   return maxFileBytes;
@@ -241,6 +242,8 @@ export async function detect(absPath, opts = {}) {
         ? 'PDF 是只读格式：可以预览，但不支持把改写内容写回'
         : spec.format === 'image'
           ? '图片没有可编辑的文本层：可以预览，但无法在此改写'
+          : spec.format === 'doc'
+            ? '旧版 Word 仅支持只读预览，请转换为 DOCX 副本后编辑'
           : `格式「${spec.format}」不支持写回`;
   }
 
@@ -963,6 +966,26 @@ export async function parse(absPath, info, opts = {}) {
   const det = info ?? (await detect(absPath, { maxFileBytes: maxBytes }));
   const format = det.format;
 
+  if (format === 'doc') {
+    const reason = '旧版 Word 文档使用只读预览；转换为 DOCX 副本后即可润色、扩写并接受修订。';
+    if (det.tooLarge) {
+      const doc = stubDoc(relPath, format, '旧版 Word 文件超过转换上限（40 MB）');
+      return { ...doc, meta: { ...doc.meta, writable: false, legacyWord: true, sourceName: basename(absPath) } };
+    }
+    try {
+      const { legacyWordDocx } = await import('./legacyWord.js');
+      const converted = await legacyWordDocx(absPath, { home: opts.home });
+      if (det.hash && converted.sourceHash !== det.hash) throw new Error('旧版 Word 文档在读取时发生变化，请重新打开');
+      const doc = await extractOffice(converted.path, 'docx', relPath);
+      return { ...doc, format, meta: { ...doc.meta, writable: false, legacyWord: true, sourceName: basename(absPath),
+        convertedFormat: 'docx', documentHash: det.hash, reason } };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const doc = stubDoc(relPath, format, /[\u4e00-\u9fff]/.test(message) ? message : `旧版 Word 转换失败：${message}`);
+      return { ...doc, meta: { ...doc.meta, writable: false, legacyWord: true, sourceName: basename(absPath) } };
+    }
+  }
+
   if (format === 'csv') {
     const { text, tooLarge } = await readText(absPath, maxBytes);
     if (tooLarge) {

package/src/host/legacyWord.js

@@ -0,0 +1,91 @@
+/** Convert legacy Word bytes into validated DOCX copies; never write a DOC. */
+import { createHash } from 'node:crypto';
+import { mkdir, mkdtemp, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+import { convert } from './convert.js';
+import { extractOffice, isZip } from './office.js';
+
+export const LEGACY_WORD_VERSION = 'legacy-word-docx-v1';
+export const LEGACY_WORD_LIMIT = 40_000_000;
+const pending = new Map();
+const digest = bytes => createHash('sha256').update(bytes).digest('hex');
+const defaultHome = () => join(tmpdir(), `dsh-doc-assistant-legacy-${digest(Buffer.from(homedir())).slice(0, 16)}`);
+function sameFile(a, b) {
+  return a.size === b.size && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs && a.ino === b.ino && a.dev === b.dev;
+}
+
+async function validateDocx(path) {
+  const info = await stat(path);
+  if (!info.size || info.size > LEGACY_WORD_LIMIT || !(await isZip(path))) throw new Error('旧版 Word 转换没有生成有效的 DOCX 文档');
+  // Extracting the actual OOXML body validates ZIP entries/XML through the
+  // same parser used by document reading, including legitimate blank docs.
+  const doc = await extractOffice(path, 'docx', basename(path));
+  if (doc.format !== 'docx' || !Array.isArray(doc.blocks)) throw new Error('转换后的 DOCX 正文无法读取');
+  return digest(await readFile(path));
+}
+
+async function cachedResult(path, metaPath, sourceHash) {
+  try {
+    const meta = JSON.parse(await readFile(metaPath, 'utf8'));
+    if (meta.version !== LEGACY_WORD_VERSION || meta.sourceHash !== sourceHash || !meta.outputHash) return null;
+    if (await validateDocx(path) !== meta.outputHash) return null;
+    return { path, sourceHash: sourceHash.slice(0, 16), contentHash: sourceHash, cached: true };
+  } catch { return null; }
+}
+
+/** Memory input is an immutable snapshot, so imports cannot corrupt originals. */
+export async function convertLegacyWordBuffer(buffer, options = {}) {
+  if (!Buffer.isBuffer(buffer) || !buffer.length) throw new Error('旧版 Word 文件内容为空，无法转换');
+  if (buffer.length > LEGACY_WORD_LIMIT) throw new Error('旧版 Word 文件超过转换上限（40 MB）');
+  const snapshot = Buffer.from(buffer);
+  const sourceHash = digest(snapshot);
+  const dir = join(options.home || defaultHome(), 'legacy-word');
+  const key = digest(Buffer.from(`${sourceHash}\u0000${LEGACY_WORD_VERSION}`));
+  const path = join(dir, `${key}.docx`); const metaPath = `${path}.json`;
+  const hit = await cachedResult(path, metaPath, sourceHash);
+  if (hit) return hit;
+  const id = `${dir}\u0000${key}`;
+  let job = pending.get(id);
+  if (!job) {
+    job = (async () => {
+      await mkdir(dir, { recursive: true, mode: 0o700 });
+      const late = await cachedResult(path, metaPath, sourceHash);
+      if (late) return late;
+      const work = await mkdtemp(join(dir, '.convert-'));
+      try {
+        const input = join(work, 'source.doc'), output = join(work, 'converted.docx');
+        await writeFile(input, snapshot, { mode: 0o600 });
+        const { enqueueRender } = await import('./covers.js');
+        try { await enqueueRender(() => (options.converter || convert)(input, output, { timeoutMs: 120_000 })); }
+        catch (error) { throw new Error(`旧版 Word 转换失败：${error.message || error}`); }
+        const outputHash = await validateDocx(output);
+        const metadata = join(work, 'meta.json');
+        await writeFile(metadata, JSON.stringify({ version: LEGACY_WORD_VERSION, sourceHash, outputHash, at: Date.now() }), { mode: 0o600 });
+        // Cache publication is private. Content and its fingerprint are checked
+        // on every hit, so a partial/crashed publication is simply a cache miss.
+        await rename(output, path); await rename(metadata, metaPath);
+        return { path, sourceHash: sourceHash.slice(0, 16), contentHash: sourceHash, cached: false };
+      } finally { await rm(work, { recursive: true, force: true }).catch(() => {}); }
+    })().finally(() => pending.delete(id));
+    pending.set(id, job);
+  }
+  return job;
+}
+
+/** Cache a read-only converted view, rejecting edits during conversion. */
+export async function legacyWordDocx(abs, options = {}) {
+  const before = await stat(abs);
+  if (!before.isFile() || !before.size || before.size > LEGACY_WORD_LIMIT) throw new Error('旧版 Word 文件为空或超过转换上限（40 MB）');
+  const bytes = await readFile(abs);
+  if (!sameFile(before, await stat(abs))) throw new Error('旧版 Word 文档在读取时发生变化，请重新打开');
+  const out = await convertLegacyWordBuffer(bytes, options);
+  if (!sameFile(before, await stat(abs)) || digest(await readFile(abs)) !== out.contentHash) throw new Error('旧版 Word 文档在转换时发生变化，请重新打开');
+  return { ...out, sourceName: basename(abs) };
+}
+
+/** Explicit user action creates a new editable sibling, never overwrites DOC. */
+export async function convertExistingLegacyDoc(deps, projectId, path) {
+  const { createLegacyWordCopy } = await import('./upload.js');
+  return createLegacyWordCopy(deps, projectId, path);
+}

package/src/host/modelVision.js

@@ -0,0 +1,44 @@
+/** Use the selected DSH route and its mounted attachment store for real image input. */
+
+export function service(deps, name) {
+  try { return deps?.ctx?.get?.(name); } catch { return undefined; }
+}
+
+export async function visionModelInfo(deps, route, signal) {
+  if (!route?.provider || !route?.model) return null;
+  const llm = service(deps, 'llm');
+  if (!llm) return null;
+  if (typeof llm.resolveModelInfo === 'function') {
+    const info = await llm.resolveModelInfo(route.provider, route.model, signal);
+    if (Array.isArray(info?.inputModalities)) return info;
+  }
+  if (typeof llm.listModels === 'function') {
+    const models = await llm.listModels(route.provider);
+    if (Array.isArray(models)) return models.find(item => item?.id === route.model) || null;
+  }
+  return null;
+}
+
+export async function supportsVision(deps, route, signal) {
+  const info = await visionModelInfo(deps, route, signal);
+  return info?.inputModalities?.includes('image') === true;
+}
+
+/** The LLM vocabulary takes a durable attachment reference, never an ad hoc base64 block. */
+export async function imageInput(deps, route, data, mediaType, name, { signal } = {}) {
+  signal?.throwIfAborted();
+  if (!route?.provider || !route?.model) throw new Error('无法确定识图模型，请重新选择文档 AI 模型');
+  const attachments = service(deps, 'attachments');
+  if (!attachments) throw new Error('DSH 图片附件服务不可用，暂时无法向模型发送文档图片');
+  if (!(data instanceof Uint8Array) || !data.byteLength) throw new Error('文档页面图片为空，无法发送模型');
+  const input = { data: Uint8Array.from(data), mediaType, name };
+  let attachment;
+  if (typeof attachments.saveImages === 'function') [attachment] = await attachments.saveImages([input]);
+  else if (typeof attachments.saveImage === 'function') {
+    attachments.validateImageBatch?.([input]);
+    attachment = await attachments.saveImage(input);
+  } else throw new Error('DSH 图片附件服务不支持保存图片，请更新 DSH');
+  signal?.throwIfAborted();
+  if (!attachment?.attachmentId) throw new Error('DSH 没有返回可用的页面图片附件');
+  return { type: 'image', attachment };
+}