dsh-prompt-rewriter 1.2.0 → 1.4.1

package/README.md

@@ -12,7 +12,7 @@ Turns the half-formed draft in your composer into a task instruction you can act
 
 ---
 
-![One click in the composer turns a draft into a complete prompt](https://raw.githubusercontent.com/huaguoxingkong/dsh-prompt-rewriter/main/docs/images/01-hero-en.gif)
+![Click the whale-tail icon on the right of the composer and the draft becomes a complete prompt in place](https://raw.githubusercontent.com/huaguoxingkong/dsh-prompt-rewriter/main/docs/images/01-hero-en.gif)
 
 ## What it fills in for you
 
@@ -36,6 +36,14 @@ The third column is not something you wrote. It read your sentence and filled it
 
 Changed your mind mid-flight? Click again to cancel. The draft stays exactly as it was — no half-finished text left behind.
 
+### For faster results, pick a stable model
+
+An enhancement is a real model call, and **how fast the result comes back depends mostly on the model you have selected**.
+
+If it feels slow, switch the session to a model that is more stable and responds faster — the same draft can take a few seconds on one model and well over ten on another. The button does not favour any particular model; it uses whichever one you picked.
+
+> Want a fixed model just for enhancement, without affecting normal chat? Open `Settings → Prompt rewriter` and turn on **Use a fixed model**.
+
 ### You can navigate away mid-rewrite
 
 Once you've clicked, you don't have to sit and wait. **Switch to another session and the task keeps running.**
@@ -63,8 +71,10 @@ That wasn't true in 1.0.x: switching sessions aborted the task, and coming back
 
 The **small dot in the button's lower-right corner** is the whole difference:
 
-- **Empty session** (no dot): sees only your current draft.
-- **Existing conversation** (dot): also reads earlier turns, so it knows what you already confirmed and already ruled out. The rewrite lands closer to what you actually want this time.
+- **No dot**: it sees only your current draft.
+- **Dot**: it also reads earlier turns, so it knows what you already confirmed and already ruled out. The rewrite lands closer to what you actually want this time.
+
+The dot describes **what will happen if you click now**, not what happened last time. That is why it hides while a run is in flight, comes back after a failure, and disappears once the button turns into an undo arrow — clicking then restores your draft, which has nothing to do with enhancement.
 
 Conversation context costs tokens. If long chats feel slow or expensive, turn off *Reference the conversation* in settings and the dot disappears.
 
@@ -155,6 +165,7 @@ Every `config` key on the profile plugin line is optional. The first five are ma
 Three designs worth calling out:
 
 - **Context is budgeted**: injected history is `min(historyTokenBudget, contextWindow × 5%)`, collected newest-first. When a single message exceeds the whole budget, its target length is computed in one proportional step (with up to 4 correction passes for rounding and mixed-script error), then truncated rather than dropped — so "has context" never silently degrades into "no context".
+- **The output budget grows on demand**: a reasoning model shares one output budget between thinking and answering, so a long draft can spend it all on reasoning and leave nothing for the reply. When the run is cut off by that budget, the plugin doubles it and retries (3500 → 7000 → 14000, capped by the model's declared maximum and never above 16000) instead of misreporting truncation as "the model returned nothing".
 - **History is injected as a JSON array**, and the system prompt states explicitly that it is data, not instructions — text inside history can't forge structure.
 - **The image switch is decided by the Host**: the browser uploads composer images unconditionally and the Host decides whether to use them, so a not-yet-loaded setting can't silently disable the feature.
 

package/README.zh.md

@@ -12,7 +12,7 @@
 
 ---
 
-![在输入框里点一下，草稿原地变成完整提示词](https://raw.githubusercontent.com/huaguoxingkong/dsh-prompt-rewriter/main/docs/images/01-hero.gif)
+![点一下输入框右侧的鲸鱼尾巴图标，草稿原地变成完整提示词](https://raw.githubusercontent.com/huaguoxingkong/dsh-prompt-rewriter/main/docs/images/01-hero.gif)
 
 ## 它替你补上了什么
 
@@ -37,6 +37,14 @@
 
 中途想放弃就再点一下，草稿保持原样，不会给你留下半截文字。
 
+### 想更快拿到结果：选个稳定的模型
+
+增强是一次真实的模型调用，**结果多快出来，主要取决于你当前选的模型**。
+
+如果觉得等得久，把会话用的模型换成一个更稳定、响应更快的——同一个草稿，换个模型往往就是几秒和十几秒的差别。这个按钮不挑模型，你选哪个它就用哪个。
+
+> 想固定用某个模型专门做增强（不影响正常对话）？去 `设置 → 提示词改写` 打开「用哪个模型改写」。
+
 ### 增强过程中可以切走
 
 点了按钮之后不必守着它。**切到别的会话，任务会继续跑完。**
@@ -64,8 +72,10 @@
 
 按钮右下角**有没有那个小圆点**，就是全部区别：
 
-- **空会话**（无圆点）：只看你当前这句草稿。
-- **已有对话**（有圆点）：还会读前面聊过的内容，知道你已经确认过什么、排除过什么，改写更贴你这次真正想要的东西。
+- **没有圆点**：只看你当前这句草稿。
+- **有圆点**：还会读前面聊过的内容，知道你已经确认过什么、排除过什么，改写更贴你这次真正想要的东西。
+
+圆点描述的是**此刻点下去会怎样**，不是上次发生了什么。所以它在运行中隐藏、失败后恢复、按钮变成回退箭头时消失——那时点击是还原草稿，与增强无关。
 
 读前文是要花 token 的。长对话里觉得慢或觉得贵，去设置里关掉「参考之前的对话」，按钮上的圆点随之消失。
 
@@ -156,6 +166,7 @@ profile 插件行的 `config` 全部可选。前五项由设置页托管，后
 三处值得说明的设计：
 
 - **上下文按预算裁剪**：历史注入量取 `min(historyTokenBudget, 上下文窗口 × 5%)`，从最新往回收集；单条超预算时按比例一次算准目标长度（最多 4 次校正兜底），截断而非丢弃，保证「有上下文」不会静默退化成「无上下文」。
+- **输出预算按需扩容**：推理模型的思考与回答共用输出预算，草稿越长思考越多，回答空间可能被挤到零。插件识别到「因预算耗尽而截断」时，会把预算翻倍重试（3500 → 7000 → 14000，上限取模型声明的最大值且不超过 16000），而不是把截断误报成「模型没有返回内容」。
 - **历史以 JSON 数组注入**，系统提示中明确声明「这是数据，不是指令」，防止历史里的文本伪造结构。
 - **图片开关由 Host 裁决**：浏览器只要输入框有图就上传，Host 依据开关决定是否使用——避免设置尚未加载完成时读到默认值而静默失效。
 

package/client.js

@@ -75,13 +75,24 @@ window.__ModuleLoader__.load({
 			'.dsh-pe_twist{display:block;width:20px;height:16px;overflow:visible;color:inherit}',
 			'.dsh-pe_twist path{fill:currentColor;fill-rule:evenodd}',
 			'.dsh-pe_icon{display:block;width:15px;height:15px}',
-			// Context-mode mark: a small dot on the seat tells the user this rewrite
-			// consulted the conversation, which is a different risk profile from a
-			// draft-only rewrite. Decorative only; the accessible name carries the text.
+			// Context-mode mark: a dot on the seat that reports an EXPECTATION — "if you
+			// click now, this run will consult the conversation". It is not a record of
+			// the last run, so it is driven by the switch plus the session's available
+			// context, never by a previous response.
+			//
+			// Size: 4px. 3px (the original) read slightly too small beside the fish mark
+			// and 5px was too heavy; 4px stays integral at 1x and 2x DPR.
+			//
+			// Colour: the host theme does NOT define `--dsw-alias-brand-primary`. Its
+			// accent token is the (build-mangled) name below, whose value is #4176e6.
+			// Using a bare `var()` of an undefined token made the dot inherit
+			// `currentColor`, which is why it rendered white. The fallback chain keeps a
+			// blue even if a future theme renames the token again.
 			'.dsh-pe_root[data-context="true"] .dsh-pe_button{position:relative}',
 			'.dsh-pe_root[data-context="true"] .dsh-pe_button::after{content:"";position:absolute;',
-			'right:2px;bottom:2px;width:3px;height:3px;border-radius:50%;',
-			'background:var(--dsw-alias-brand-primary);pointer-events:none}',
+			'right:2px;bottom:2px;width:4px;height:4px;border-radius:50%;',
+			'background:var(--dsw-alias-brand-primary-new-colorprimary-new-color,#4176e6);',
+			'pointer-events:none}',
 			// Visible failure notice. A red mark alone never told the user WHY the run
 			// failed; the message now has a real, on-screen outlet instead of living
 			// only in `title` and the visually hidden live region.
@@ -379,8 +390,57 @@ window.__ModuleLoader__.load({
 			const busy = task?.phase === 'running';
 			const failure = task?.failure ?? null;
 			const announce = task?.announce ?? null;
+			// `contextAware` records what the LAST run did. It feeds the accessible name
+			// only; the seat's dot must not use it (see `willUseContext` below).
 			const contextAware = task?.contextAware === true;
 			const restore = task?.restore ?? null;
+
+			// What the NEXT click will do — the only thing the dot reports.
+			//
+			// Two facts decide it, both knowable before any run: whether the
+			// reference-context switch is on, and whether this session actually has
+			// conversation to consult. A previous run's outcome is irrelevant: a failed
+			// or never-attempted enhancement does not change what the next one will do.
+			const [willUseContext, setWillUseContext] = useState(false);
+			// Exposed on the seat as data-ctx-debug so a missing dot can be diagnosed
+			// without guessing: it records which of the two facts was false, and whether
+			// either request failed. Not shown to users; harmless in the DOM.
+			const [ctxProbe, setCtxProbe] = useState('pending');
+			useEffect(() => {
+				let cancelled = false;
+				const read = async () => {
+					try {
+						const [settingsResponse, statusResponse] = await Promise.all([
+							fetch('/api/prompt-enhance/settings', { credentials: 'same-origin' }),
+							fetch(`/api/prompt-enhance/context-status?sessionId=${encodeURIComponent(sessionId)}`, { credentials: 'same-origin' }),
+						]);
+						if (cancelled) return;
+						const settings = settingsResponse.ok ? await settingsResponse.json() : null;
+						const status = statusResponse.ok ? await statusResponse.json() : null;
+						if (cancelled) return;
+						const switchOn = settings?.ok === true && settings.values?.referenceContext !== false;
+						const hasContext = status?.ok === true && status.hasContext === true;
+						setWillUseContext(switchOn && hasContext);
+						setCtxProbe(
+							`sw=${switchOn ? 1 : 0},hc=${hasContext ? 1 : 0},`
+							+ `sHttp=${settingsResponse.status},cHttp=${statusResponse.status}`,
+						);
+					} catch (error) {
+						// An unreachable route means "we cannot promise context"; showing no dot
+						// is the honest default rather than promising a context-aware run.
+						if (!cancelled) {
+							setWillUseContext(false);
+							setCtxProbe(`error:${error?.message ?? 'unknown'}`);
+						}
+					}
+				};
+				read();
+				return () => {
+					cancelled = true;
+				};
+				// Re-read when the session changes or when a run finishes: the first turn
+				// of a conversation creates the context this mark advertises.
+			}, [sessionId, task?.phase]);
 			const latestRev = useRef(draftRev);
 			latestRev.current = draftRev;
 
@@ -633,6 +693,11 @@ window.__ModuleLoader__.load({
 			if (inputActions === undefined || typeof inputActions.insertText !== 'function') return null;
 
 			const canUndo = restore !== null && restore.pending !== true && !busy;
+			// The seat appears only when there is something to act on. An empty composer
+			// with no work in flight has nothing to enhance, so the control stays out of
+			// the way entirely — an available context dot is not a reason to render it,
+			// because a mark on a button that cannot do anything is just noise in the
+			// toolbar for every conversation that has history.
 			const visible = busy || canUndo || failure !== null || draft.trim().length > 0;
 			if (!visible || phase !== 'plain') return null;
 
@@ -644,19 +709,31 @@ window.__ModuleLoader__.load({
 					: failure !== null
 						? t('state.failedWith', { reason: failure })
 						: t('label.idle');
-			// Say so in the accessible name when the rewrite consulted the conversation.
+			// The accessible name may still mention what the last run did; that is a
+			// statement about the past and belongs in a tooltip, not in the dot.
 			const title = contextAware && !busy ? t('label.contextAware', { base: baseTitle }) : baseTitle;
 			const onClick = busy ? run : canUndo ? undo : run;
 			// A pause leaves `failure` null, so the mark returns to the resting fish and
 			// only the live region carries the cancellation text.
 			const status = announce !== null ? announce : title;
+			// The dot advertises the next click, so it is suppressed while a run is in
+			// flight (there is no "next click" to describe) and returns afterwards —
+			// including after a failure, because a failed run does not change what the
+			// next one would do.
+			//
+			// It is also suppressed on the UNDO seat: in that state the button restores
+			// the previous draft instead of starting an enhancement, so a mark describing
+			// "what the next enhancement will do" would describe an action this button no
+			// longer performs.
+			const showContextMark = willUseContext && !busy && !canUndo;
 
 			return h(
 				'div',
 				{
 					className: 'dsh-pe_root',
 					'data-prompt-enhance': '1',
-					'data-context': contextAware && !busy ? 'true' : 'false',
+					'data-context': showContextMark ? 'true' : 'false',
+					'data-ctx-debug': ctxProbe,
 					'data-notice': failure !== null ? 'true' : 'false',
 				},
 				h(

package/index.js

@@ -15,6 +15,10 @@
  * @module dsh-prompt-rewriter
  */
 
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { zstdDecompressSync } from 'node:zlib';
 import z from '@deepseek-ai/schemastery';
 
 /** Exact route the browser half posts to. */
@@ -69,9 +73,59 @@ const DEFAULTS = Object.freeze({
 	referenceContext: true,
 });
 
+/** Hard stop for the adaptive budget, independent of what a model declares. */
+const MAX_OUTPUT_CEILING = 16000;
+
 /** Share of a model's context window the history may ever consume. */
 const HISTORY_WINDOW_SHARE = 0.05;
 
+/**
+ * Extra completion budget granted on top of `maxOutputTokens`.
+ *
+ * On reasoning-capable models the completion budget covers reasoning AND visible
+ * text, and the adapter reports reasoning as `reasoning-delta` — which this plugin
+ * deliberately does not treat as output. A budget sized only for the rewritten
+ * prompt could therefore be spent entirely on thinking, producing zero text and an
+ * "empty response" that looks like a model fault. The headroom keeps the answer
+ * reachable without changing what the caller asked for.
+ */
+const REASONING_HEADROOM_TOKENS = 1500;
+
+/**
+ * How many times a truncated run may be retried with a larger budget.
+ * Two doublings from the starting budget cover 4x, which is enough for the
+ * reasoning overhead of a long draft without risking a runaway cost.
+ */
+const MAX_BUDGET_ATTEMPTS = 3;
+
+/**
+ * Resolve the largest completion budget this model will accept.
+ *
+ * The plugin must not invent a ceiling: an adapter rejects a `maxTokens` above the
+ * model's own capacity, so the retry ladder has to stop at what the model declares.
+ * When the metadata is unavailable the configured budget stands, which keeps the
+ * old single-shot behaviour rather than guessing high and failing.
+ *
+ * @param scope - plugin context exposing `ctx.llm`.
+ * @param route - provider/model selection.
+ * @param signal - cancellation.
+ * @param config - resolved limits.
+ * @returns the ceiling in tokens.
+ */
+async function resolveTokenCeiling(scope, route, signal, config, cache) {
+	const requested = config.maxOutputTokens + REASONING_HEADROOM_TOKENS;
+	const key = `${route.provider}\u0000${route.model}`;
+	// Reuse the context-window lookup: same metadata, same cache entry, one adapter
+	// call per route instead of two.
+	await resolveContextWindow(scope, route, signal, cache);
+	const declared = cache.get(key)?.outputCap;
+	if (Number.isInteger(declared) && declared > 0) return Math.max(requested, Math.min(declared, MAX_OUTPUT_CEILING));
+	// No declared capacity: allow the full ladder up to the hard ceiling. Returning
+	// `requested` (or 2x it) made the first or second truncation hit the ceiling, so
+	// the adaptive budget silently degraded back to one retry.
+	return MAX_OUTPUT_CEILING;
+}
+
 /**
  * CJK code-point ranges, checked numerically instead of by regex.
  * `estimateTokens` runs once per character over the whole candidate history, so
@@ -109,6 +163,10 @@ const BASE_RULES = [
 	// Ambiguity must be surfaced, never silently resolved: guessing a specific value
 	// invents a requirement, while leaving it blank silently degrades the prompt.
 	'- When a detail the task genuinely needs is missing or ambiguous, do NOT invent a value and do NOT drop the requirement. Write an explicit placeholder the user can fill (for example "<target file path>") and say briefly what is expected there. Prefer at most a few such placeholders; if the draft already settles a detail, never reopen it.',
+	// A vague draft can tempt the model to template every field, producing a form of
+	// placeholders instead of a usable prompt. The cap below forces a priority call:
+	// keep the blanks that block execution, summarise the rest in one line.
+	'- Use at most 3 placeholders in total. If more details are missing than that, keep only the ones that block execution, and fold the remainder into a single closing line such as "其余细节请补充" rather than inventing a placeholder for each. A prompt the user can run after filling two blanks is better than a complete form they must fill entirely.',
 	// The instruction an executing model follows most reliably is a direct one.
 	'- Address the executing assistant directly and in the imperative. State the task as an instruction to be carried out, not as a description of a task that exists.',
 	'- Keep it tight. No filler, no praise, no meta commentary. Do not add markdown headings unless the draft itself is a document request, and do not use a heading for every field — prefer short labelled lines or a compact list when structure genuinely helps.',
@@ -424,6 +482,153 @@ function trimNewestFirst(derived, config, budget) {
 	return { turns: picked, truncated, tokens: used };
 }
 
+// ---------------------------------------------------------------------------
+// Persisted-log fallback
+// ---------------------------------------------------------------------------
+// The Host keeps sessions on disk as `session.vN.jsonl[.zstd]` under
+// `~/.dsh/sessions/<workspace>/<session-id>/`. After a restart a session that has
+// not been reopened has no in-memory log, so anything that asks "does this
+// conversation have history?" must be able to look at the artifact itself.
+
+/** zstd frame magic; the log is written as one independent frame per row. */
+const ZSTD_MAGIC = Buffer.from([0x28, 0xb5, 0x2f, 0xfd]);
+
+/**
+ * Cache of sessionId → { mtimeMs, hasUser }.
+ *
+ * The probe is cheap but not free (directory walk + a few frame decodes), and the
+ * composer asks on every mount. Keying on the file's mtime keeps the cache honest:
+ * a conversation that gains its first turn changes the file, so the next probe
+ * re-reads instead of serving a stale "no".
+ */
+const persistedProbeCache = new Map();
+
+/**
+ * Workspace directories under the session store, cached for a short while.
+ *
+ * `findSessionLog` has to look for the session's directory inside each workspace.
+ * Re-reading the workspace list on every probe is wasted work: there are hundreds
+ * of session directories and the workspace set changes only when the user opens a
+ * new project. A short TTL keeps a newly created workspace discoverable without
+ * paying a directory read per request.
+ */
+let workspaceCache = { at: 0, dirs: [] };
+const WORKSPACE_CACHE_MS = 30_000;
+
+/**
+ * The session store root.
+ *
+ * Overridable through `DSH_SESSIONS_DIR` so the probe can be exercised without
+ * touching the user's real store, and so a deployment with a non-default DSH home
+ * still works.
+ * @returns the absolute path of the session store.
+ */
+function sessionStoreRoot() {
+	const override = process.env.DSH_SESSIONS_DIR;
+	if (typeof override === 'string' && override.length > 0) return override;
+	return path.join(os.homedir(), '.dsh', 'sessions');
+}
+
+/** @returns the workspace directories under the session store. */
+function sessionWorkspaces() {
+	const now = Date.now();
+	if (now - workspaceCache.at < WORKSPACE_CACHE_MS && workspaceCache.dirs.length > 0) return workspaceCache.dirs;
+	try {
+		const root = sessionStoreRoot();
+		const dirs = fs.readdirSync(root).filter((name) => !name.startsWith('.'));
+		workspaceCache = { at: now, dirs };
+		return dirs;
+	} catch {
+		return [];
+	}
+}
+
+/** Locate one session's log file, or undefined. */
+function findSessionLog(sessionId) {
+	if (typeof sessionId !== 'string' || sessionId.length === 0) return undefined;
+	try {
+		const root = sessionStoreRoot();
+		for (const workspace of sessionWorkspaces()) {
+			const dir = path.join(root, workspace, sessionId);
+			let entries;
+			try {
+				entries = fs.readdirSync(dir);
+			} catch {
+				continue;
+			}
+			const log = entries.find((name) => /^session\.v\d+\.jsonl(\.zstd)?$/u.test(name));
+			if (log !== undefined) return path.join(dir, log);
+		}
+	} catch {
+		// A missing or unreadable store simply means "no persisted history".
+	}
+	return undefined;
+}
+
+/**
+ * Whether a persisted log already contains a user turn.
+ *
+ * Decodes frame by frame and stops at the first row that proves a user message, so
+ * the common case reads a handful of frames instead of the whole file (measured:
+ * 4 of 413 frames, ~0.2ms versus ~18ms for a full decode).
+ *
+ * @param sessionId - the Session id.
+ * @returns true when the log holds at least one user message.
+ */
+function persistedLogHasUser(sessionId) {
+	const file = findSessionLog(sessionId);
+	if (file === undefined) return false;
+	let stat;
+	try {
+		stat = fs.statSync(file);
+	} catch {
+		return false;
+	}
+	const cached = persistedProbeCache.get(sessionId);
+	if (cached !== undefined && cached.mtimeMs === stat.mtimeMs) return cached.hasUser;
+
+	let hasUser = false;
+	try {
+		const raw = fs.readFileSync(file);
+		if (file.endsWith('.zstd')) {
+			const starts = [];
+			let at = 0;
+			while ((at = raw.indexOf(ZSTD_MAGIC, at)) >= 0) {
+				starts.push(at);
+				at += ZSTD_MAGIC.length;
+			}
+			let pending = '';
+			for (let i = 0; i < starts.length && !hasUser; i += 1) {
+				const from = starts[i];
+				const to = i + 1 < starts.length ? starts[i + 1] : raw.length;
+				let chunk;
+				try {
+					chunk = zstdDecompressSync(raw.subarray(from, to)).toString('utf8');
+				} catch {
+					continue;
+				}
+				pending += chunk;
+				const cut = pending.lastIndexOf('\n');
+				if (cut < 0) continue;
+				hasUser = logTextHasUser(pending.slice(0, cut));
+				pending = pending.slice(cut + 1);
+			}
+		} else {
+			hasUser = logTextHasUser(raw.toString('utf8'));
+		}
+	} catch {
+		hasUser = false;
+	}
+	persistedProbeCache.set(sessionId, { mtimeMs: stat.mtimeMs, hasUser });
+	return hasUser;
+}
+
+/** Cheap textual test for a user-authored row in JSONL session text. */
+function logTextHasUser(text) {
+	// Session rows carry the author as `"role":"user"` inside a message payload.
+	return /"role"\s*:\s*"user"/u.test(text);
+}
+
 /**
  * Read the derived message log for one session.
  * @param scope - plugin context with optional Session services.
@@ -444,6 +649,37 @@ function readDerivedMessages(scope, sessionId) {
 	}
 }
 
+/**
+ * Whether this session already has conversation the rewrite could consult.
+ *
+ * Two sources, cheapest first:
+ *
+ * 1. The live Session, via `deriveMessages()`. Authoritative and free when the
+ *    conversation is loaded.
+ * 2. The persisted log on disk. After a restart the Host keeps sessions on disk and
+ *    only materialises a log once something touches it, so `deriveMessages()` is
+ *    empty for a conversation the user has not reopened — yet the conversation is
+ *    still there, and the next enhancement WILL read it (see `readDerivedMessages`,
+ *    which uses the same fallback). Without this second source the mark vanished
+ *    after every restart until the user sent a message.
+ *
+ * The disk probe stops at the first frame that proves a user message exists, so the
+ * usual case costs a few frames rather than the whole file.
+ *
+ * @param scope - plugin context with optional Session services.
+ * @param sessionId - the browser-reported Session id.
+ * @returns true when at least one user turn exists.
+ */
+function sessionHasContext(scope, sessionId) {
+	const derived = readDerivedMessages(scope, sessionId);
+	for (const message of derived) {
+		if (message?.role === 'user' && messageText(message).length > 0) return true;
+	}
+	if (derived.length > 0) return false;
+	// Nothing in memory: fall back to the persisted log.
+	return persistedLogHasUser(sessionId);
+}
+
 /**
  * Collect the conversation that precedes the draft.
  * @param derived - messages from {@link readDerivedMessages}.
@@ -479,19 +715,25 @@ function collectHistory(derived, config, contextWindow) {
 async function resolveContextWindow(scope, route, signal, cache) {
 	const key = `${route.provider}\u0000${route.model}`;
 	const hit = cache.get(key);
-	if (hit !== undefined) return hit;
+	if (hit !== undefined) return hit.window;
 	try {
 		const info = await scope.llm.resolveModelInfo(route.provider, route.model, signal);
 		const window = info?.context?.contextWindow;
 		const resolved = Number.isInteger(window) && window > 0 ? window : undefined;
+		// The declared output capacity rides along in the same entry: it comes from the
+		// same metadata call, and querying the adapter twice per request would defeat
+		// the point of this cache (each call is an adapter round trip).
+		const declaredOutput = info?.limits?.maxOutputTokens ?? info?.maxOutputTokens ?? info?.context?.maxOutputTokens;
+		const outputCap = Number.isInteger(declaredOutput) && declaredOutput > 0 ? declaredOutput : undefined;
 		// Cache both a real window and a definitive "no window" so a provider that
 		// omits the field is not re-queried on every request.
-		cache.set(key, resolved);
+		cache.set(key, { window: resolved, outputCap });
 		return resolved;
 	} catch (error) {
 		// A cancelled lookup says nothing about the model; caching it would poison
-		// every later request, so only genuine answers are memoized.
-		if (!signal.aborted) cache.set(key, undefined);
+		// every later request. The same holds for any transient metadata failure:
+		// only a definitive ANSWER is memoized, so a failure leaves the cache
+		// untouched and the next request retries.
 		return undefined;
 	}
 }
@@ -579,6 +821,18 @@ async function admitComposerImage(scope, image, signal) {
 
 /**
  * Stream one enhancement request and return the plain rewritten prompt.
+ *
+ * The completion budget is ADAPTIVE. A reasoning model spends `maxTokens` on
+ * thinking before it writes anything, so the budget a plain answer needs is not
+ * the budget a reasoning model needs — and the extra amount depends on the draft,
+ * which the plugin cannot know in advance. Guessing one number is what made long
+ * drafts, drafts containing a URL, or drafts with attachments fail with an empty
+ * reply: the guess was simply too small.
+ *
+ * So the budget grows on demand. If the model stops with `max-tokens`, the run is
+ * retried with a larger budget, up to a ceiling derived from the model's own
+ * capacity. The user sees one slightly slower request, never a spurious failure.
+ *
  * @param scope - plugin context exposing `ctx.llm`.
  * @param config - resolved limits.
  * @param route - provider/model/reasoning selection.
@@ -588,55 +842,98 @@ async function admitComposerImage(scope, image, signal) {
  * @param signal - combined cancellation for this request.
  * @returns the rewritten prompt text.
  */
-async function generate(scope, config, route, draft, history, images, signal) {
+async function generate(scope, config, route, draft, history, images, signal, windowCache) {
 	const llm = scope.llm;
 	if (llm === undefined) throw new EnhanceFailure('UNAVAILABLE', '当前运行的 Harness 未提供模型服务，无法增强提示词。');
 	const providers = llm.listProviders();
 	if (!providers.some((entry) => entry.id === route.provider)) {
 		throw new EnhanceFailure('NO_ADAPTER', `模型提供商「${route.provider}」未启用，请重新选择模型。`);
 	}
-	let call;
-	try {
-		call = await llm.prepareCall(
-			{
-				provider: route.provider,
-				model: route.model,
-				maxTokens: config.maxOutputTokens,
-				...(route.reasoningEffort === undefined ? {} : { reasoningEffort: route.reasoningEffort }),
-			},
-			signal,
-		);
-	} catch (error) {
-		if (signal.aborted) throw error;
-		const code = typeof error?.code === 'string' ? error.code : 'UNKNOWN';
-		throw new EnhanceFailure(code, describeFailure(code, `模型准备失败：${error?.message ?? '未知错误'}`));
-	}
+
 	const system = history.hasContext ? SYSTEM_PROMPT_CONTEXT : SYSTEM_PROMPT_PLAIN;
-	let text = '';
-	let finish;
-	for await (const chunk of call.stream({
-		...call.config,
-		system,
-		messages: [{ role: 'user', content: buildUserContent(draft, history, images) }],
-		signal,
-	})) {
+	const messages = [{ role: 'user', content: buildUserContent(draft, history, images) }];
+
+	// Start from the configured answer budget plus reasoning headroom, then grow.
+	let budget = config.maxOutputTokens + REASONING_HEADROOM_TOKENS;
+	const ceiling = await resolveTokenCeiling(scope, route, signal, config, windowCache);
+	let lastTruncation = null;
+
+	for (let attempt = 0; attempt < MAX_BUDGET_ATTEMPTS; attempt += 1) {
+		let call;
+		try {
+			call = await llm.prepareCall(
+				{
+					provider: route.provider,
+					model: route.model,
+					maxTokens: Math.min(budget, ceiling),
+					...(route.reasoningEffort === undefined ? {} : { reasoningEffort: route.reasoningEffort }),
+				},
+				signal,
+			);
+		} catch (error) {
+			if (signal.aborted) throw error;
+			const code = typeof error?.code === 'string' ? error.code : 'UNKNOWN';
+			throw new EnhanceFailure(code, describeFailure(code, `模型准备失败：${error?.message ?? '未知错误'}`));
+		}
+
+		let text = '';
+		let finish;
+		// Reasoning is counted for diagnosis only; it is never part of the prompt.
+		let reasoningChars = 0;
+		for await (const chunk of call.stream({ ...call.config, system, messages, signal })) {
+			signal.throwIfAborted();
+			if (chunk.type === 'text-delta') {
+				text += chunk.text;
+				if (text.length > config.maxOutputChars * 4) throw new EnhanceFailure('TOO_LARGE', '模型返回内容过长，已停止，草稿保持不变。');
+			} else if (chunk.type === 'reasoning-delta') {
+				reasoningChars += typeof chunk.text === 'string' ? chunk.text.length : 0;
+			} else if (chunk.type === 'finish') {
+				finish = chunk.reason;
+			}
+		}
 		signal.throwIfAborted();
-		if (chunk.type === 'text-delta') {
-			text += chunk.text;
-			if (text.length > config.maxOutputChars * 4) throw new EnhanceFailure('TOO_LARGE', '模型返回内容过长，已停止，草稿保持不变。');
-		} else if (chunk.type === 'finish') {
-			finish = chunk.reason;
+
+		if (finish !== undefined && (finish.kind === 'error' || finish.kind === 'aborted')) {
+			const failure = finish.failure;
+			const code = typeof failure?.code === 'string' ? failure.code : 'UNKNOWN';
+			throw new EnhanceFailure(code, describeFailure(code, `模型请求失败${failure?.message === undefined ? '' : `：${failure.message}`}`));
 		}
+
+		// The budget ran out. `max-tokens` is the adapter's explicit signal, and it is
+		// not an error: retry larger rather than blaming the model.
+		if (finish !== undefined && finish.kind === 'max-tokens') {
+			lastTruncation = { reasoningChars };
+			if (budget >= ceiling) break;
+			budget = Math.min(budget * 2, ceiling);
+			continue;
+		}
+
+		const normalized = normalizeOutput(text, config.maxOutputChars);
+		if (normalized.length === 0) {
+			// Nothing usable. Reasoning with no text means the budget was spent thinking,
+			// which a larger retry can still rescue.
+			lastTruncation = { reasoningChars };
+			if (reasoningChars > 0 && budget < ceiling) {
+				budget = Math.min(budget * 2, ceiling);
+				continue;
+			}
+			if (reasoningChars > 0) {
+				throw new EnhanceFailure('EMPTY_REASONING', '模型把输出预算用在了思考上，没有产出提示词。请重试，或在「设置 → 提示词增强」换一个模型。');
+			}
+			throw new EnhanceFailure('EMPTY', '模型没有返回可用的提示词，草稿保持不变。');
+		}
+		return normalized;
 	}
-	signal.throwIfAborted();
-	if (finish !== undefined && (finish.kind === 'error' || finish.kind === 'aborted')) {
-		const failure = finish.failure;
-		const code = typeof failure?.code === 'string' ? failure.code : 'UNKNOWN';
-		throw new EnhanceFailure(code, describeFailure(code, `模型请求失败${failure?.message === undefined ? '' : `：${failure.message}`}`));
-	}
-	const normalized = normalizeOutput(text, config.maxOutputChars);
-	if (normalized.length === 0) throw new EnhanceFailure('EMPTY', '模型没有返回可用的提示词，草稿保持不变。');
-	return normalized;
+
+	// Every attempt ran out of budget. Say so precisely: the cause is the length
+	// limit, and the fix is a shorter draft or a larger ceiling — not a retry.
+	const reasoning = lastTruncation?.reasoningChars ?? 0;
+	throw new EnhanceFailure(
+		'OUTPUT_TRUNCATED',
+		reasoning > 0
+			? `模型在 ${ceiling} token 的输出上限内仍在思考，未能产出提示词。请缩短草稿后重试。`
+			: `模型输出达到 ${ceiling} token 上限仍未完成。请缩短草稿后重试。`,
+	);
 }
 
 /**
@@ -738,7 +1035,7 @@ async function handle(scope, config, request, lifetime, windowCache) {
 			}
 		}
 
-		const text = await generate(scope, config, route, draft, history, images, signal);
+		const text = await generate(scope, config, route, draft, history, images, signal, windowCache);
 		return Response.json({
 			ok: true,
 			text,
@@ -764,6 +1061,16 @@ export const inject = ['connection'];
 /** Exact route the browser half uses to read and write the user's preferences. */
 const SETTINGS_PATH = '/api/prompt-enhance/settings';
 
+/**
+ * Read-only route that answers "would an enhancement started right now consult
+ * this session's conversation?".
+ *
+ * The composer needs this BEFORE any run so its mark can describe the next click
+ * rather than the previous result. It is deliberately cheap: no model call, no
+ * token accounting, just a scan for a prior user turn.
+ */
+const CONTEXT_STATUS_PATH = '/api/prompt-enhance/context-status';
+
 /** The row config keys the settings page may write. */
 const SETTING_KEYS = Object.freeze(['enhanceProvider', 'enhanceModel', 'useCustomModel', 'referenceImages', 'referenceContext']);
 
@@ -925,6 +1232,19 @@ export function apply(ctx, rawConfig) {
 			}),
 		'dsh-prompt-rewriter: settings route',
 	);
+	ctx.effect(
+		() =>
+			ctx.connection.fetch.register({
+				path: CONTEXT_STATUS_PATH,
+				methods: ['GET'],
+				requestBody: 'buffered',
+				fetch: (request) => {
+					const sessionId = new URL(request.url).searchParams.get('sessionId') ?? undefined;
+					return Response.json({ ok: true, hasContext: sessionHasContext(ctx, sessionId) });
+				},
+			}),
+		'dsh-prompt-rewriter: context-status route',
+	);
 	ctx.inject(['llm'], (scope) => {
 		scope.effect(
 			() =>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-prompt-rewriter",
-  "version": "1.2.0",
+  "version": "1.4.1",
   "description": "One-click prompt enhancement beside the DeepSeek Harness composer: rewrites a draft in place without sending it.",
   "type": "module",
   "icon": "icon.svg",