@entrorove/skill 0.1.69 → 0.1.71

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.71 — 2026-10-20
+
+- 通用分离源码依赖事实与未知构建行为：动态配置、宏及加载器保留真实哈希与只读来源，不执行项目代码，不把构建未知标为完整。原审批与独立 S/M 签名仅允许已知源码的非结构修改；隐私文件、路径、资源预算、未知目标及配置漂移继续明确拒绝，实际构建与测试仍需原流程验收。
+- Separate raw source dependency facts from opaque build behavior across projects. Preserve actual hashes and read-only origins for dynamic configuration, macros and loaders without executing project code or claiming compiled completeness. Original approvals and separate S/M signatures permit only known-source nonstructural modifications; private files, unsafe paths, resource budgets, unknown targets and configuration drift remain explicit refusals. Actual builds and tests still require original-flow acceptance.
+
+## 0.1.70 — 2026-10-20
+
+- 云端沙箱固定中英文输出语言，界面、通知和 Blueprint 文档正文按对应语种显示，原始证据单列来源并保留旧流程精确版本。修复 uni-app 默认条件编译分支解析与长扫描后的原任务签名挑战衔接，核对真实读集并保留原审批、完整路径、快照及失败历史。
+- Freeze cloud sandbox output language across presentation, notifications and Blueprint document prose; preserve original source evidence and exact historical runtimes. Fix default uni-app conditional branch inspection and renew the original signing challenge after long scans, rechecking actual reads while retaining approvals, complete paths, snapshots and failure history.
+
 ## 0.1.69 — 2026-10-20
 
 - 新增首次范围门禁前的构建上下文纠正：原账号审核真实配置和构建证据，原 S 签名完整路径快照，通过服务挑战追加上下文权威记录；保留原 flow、绑定、旧上下文和失败历史，不授予写入或完成权限。

package/IDE-EXECUTION.md

@@ -33,9 +33,9 @@ On first use or after a material agreement revision, the CLI returns a Confirm P
 
 ### IDE display and cloud planning entry
 
-For a new engineering task, run `npx --yes --prefer-online @entrorove/skill@latest invoke` with `operation: "start"` and the actual task facts below. The CLI reads the authenticated account's sandbox preference before dispatch. An enabled account returns `status: "needs-input"` and a cloud choice, with no model call yet. This is a routing question, not an execution failure. Render it immediately with the host's question tool or native UI; if unavailable, display `interaction.chatFallback` and collect the answer. A collapsed command log is insufficient. Offer **确认** and **退出，采用本地方案**. After confirmation call the returned `cloud-task` callback with its exact original payload and `sandboxChoice: "use"`; exit repeats the original `start` with top-level `sandboxChoice: "local"`. Preserve the original goal, risk, work type and requirements. A disabled account continues through its configured local workflow; unavailable preferences stop entry explicitly. Reuse a prior explicit choice while resuming this task. Silence never authorizes cloud consumption.
+For a new engineering task, run `npx --yes --prefer-online @entrorove/skill@latest invoke` with `operation: "start"` and the actual task facts below. The CLI reads the authenticated account's sandbox preference before dispatch. An enabled account returns `status: "needs-input"` and a cloud choice, with no model call yet. This is a routing question, not an execution failure. Render it immediately with the host's question tool or native UI; if unavailable, display `interaction.chatFallback` and collect the answer. A collapsed command log is insufficient. Use the returned locale-specific labels for **Use cloud sandbox** and **Continue locally**. After confirmation call the returned `cloud-task` callback with its exact original payload and `sandboxChoice: "use"`; exit repeats the original `start` with top-level `sandboxChoice: "local"`. Preserve the original goal, risk, work type and requirements. A disabled account continues through its configured local workflow; unavailable preferences stop entry explicitly. Reuse a prior explicit choice while resuming this task. Silence never authorizes cloud consumption.
 
-For an explicit cloud planning request without an existing start, `cloud-task` accepts `{"goal":"<actual goal>","ideTaskId":"<current IDE task ID, when available>"}` on stdin and returns the same choice. Do not start both routes for one task.
+For an explicit cloud planning request without an existing start, `cloud-task` accepts `{"goal":"<actual goal>","ideTaskId":"<current IDE task ID, when available>","outputLocale":"en"}` on stdin and returns the same choice. Use `zh` for Chinese output. The creating page or explicit IDE request freezes this language; keep the original goal unchanged. A later viewer language switch changes presentation only. Cross-language historical output and raw evidence remain clearly labelled source details. New localized Blueprint documents use the frozen language for their prose and preserve original structured values in closed source appendices. Do not start both routes for one task.
 
 Images attached to a cloud planning task use `images: [{"path":"<explicit absolute image path>","detail":"original"}]` or `images: [{"url":"data:image/png;base64,<canonical bytes>","detail":"auto"}]`. For ordinary `invoke` task entry, keep `images` at the envelope's top level, outside the immutable `input.task`; the original cloud-choice callback carries them forward. Render the returned choice before sending. File paths are read only after `use`, and a local choice retains the attachment references without reading or uploading them. Never scan for images, copy a local path into a remote URL, omit attachments silently, or describe a text-only classification as image analysis.
 
@@ -100,7 +100,7 @@ First inspect the actual host configurations and the real build source that copi
 
 The SDK signs the exact proposal with the original S key. The service checks the original accepted owner, task, repository, signer, complete target set and current context revision, then issues an original-owner Confirm Protocol question showing the exact old/new mappings and observed evidence hashes. Show that unchanged question using the host question tool. Only the user's actual answer may call its original `interaction-answer` callback. Existing task authorization does not fabricate this exact context approval; silence remains pending. These configuration and build-evidence files remain read-only and hash-bound during later scope refreshes and file-role amendments; this approval cannot authorize changing their alias semantics or source bytes.
 
-After approval, run `scope-context` with `{ "action": "apply", "flowId": "<original flow>", "proposalId": "<returned proposal>", "proposalDigest": "<returned digest>" }`. It obtains a fresh server challenge, verifies a real copied snapshot and import graph using all original target paths and the proposed contexts, and submits the original S signature. Configuration or build-evidence drift, an unresolved actual alias, stale revision, expired/consumed nonce, foreign identity or missing approval rejects the attempt. No context approval grants writes or completes the task.
+After approval, run `scope-context` with `{ "action": "apply", "flowId": "<original flow>", "proposalId": "<returned proposal>", "proposalDigest": "<returned digest>" }`. It prepares and independently inspects a real copied snapshot and import graph using all original target paths and the proposed contexts, then obtains a fresh server challenge before the original S signature. The short challenge lifetime remains unchanged. Its actual read set, source hashes, original missing resolver candidates, build evidence and snapshot are rechecked after that request; drift rejects signing. A local parser failure is archived, and retrying the identical approved input reuses its original snapshot only while the actual files still match. Unknown remote outcomes require the original GET recovery before any new challenge. Configuration or build-evidence drift, an unresolved actual alias, stale revision, expired/consumed nonce, foreign identity or missing approval rejects the attempt. No context approval grants writes or completes the task.
 
 Successful application appends a server-signed context authority and local history while preserving the original binding bytes. Retry `scope-connect` with its returned complete `nextInput`, then resume the original gate request. Later ordinary scope refreshes and `scope-amend` use that effective context authority; their signed facts bind its digest and exact mappings. M snapshot preparation and independent guarded writes recover the same context authority from the original private history and snapshot without a caller-selected mapping or S private-key read; their separate original M approval remains required. Status uses `{ "action": "status", "flowId": "<original flow>" }`. An unknown POST must recover its original request with GET through the saved journal; never repeat a POST to guess its outcome. This recovery is unavailable after the first accepted scope facts, successful gate, frozen plan or execution; preserve that later flow's original authority instead. The existing strict handoff protocol does not transfer a corrected context head; do not choose another receiver to bypass this binding.
 
@@ -211,3 +211,5 @@ Feedback command example (replace the request ID with the original successful in
 Ordinary Windows scope inspection resolves an absolute Git for Windows `git.exe` from its installation or absolute PATH directories, including paths containing spaces. It never invokes `/usr/bin/git` on Windows, a shell wrapper or a Git executable inside the inspected repository. Missing Git gives `ENTROROVE_GIT_UNAVAILABLE` and requires installing Git for Windows before reconnecting the original scope.
 
 The fixed Git byte-metering adapter ships hash-pinned precompiled libraries for Darwin and glibc Linux on arm64/x64. It extracts the selected library on first use; it never invokes a C compiler on the user machine. Darwin requires Apple’s trusted Git (Xcode or Command Line Tools), xcrun and codesign; Linux requires the trusted `/usr/bin/git` and glibc. Native comparisons with enforced source-read budgets remain restricted to these platforms. An unsupported native budget adapter returns `ENTROROVE_GIT_READER_UNSUPPORTED`; do not bypass its budget or claim an ordinary Windows inspection verifies that separate capability.
+
+Conditional uni-app Vue sources are inspected across every supported feasible default platform and version branch, retaining raw source hashes and physical diagnostic locations. Unknown macros, unsupported expressions, custom build overrides or environment files that could change conditional semantics are rejected explicitly. A passing fixture does not prove that another project’s full scope passed; retry that project’s original approved operation and retain its actual result.

package/SKILL.md

@@ -5,7 +5,7 @@ description: Execute a task selected for Entrorove through explicit SDK operatio
 
 # entrorove · 熵巡
 
-Version: 0.1.69.
+Version: 0.1.71.
 
 Entrorove applies only to the task for which it is selected; reading these instructions, discovering capabilities or installing the package never selects or governs another task. Hooks are optional. Reading this document or calling an entry once does not execute the task. On every later turn, including after compaction, continue the original task and its required next operation before dependent work. Keep the original goal, scope, account, flow, cloud task and failure records. Never describe planning, a reported step or model output as verified delivery.
 
@@ -19,10 +19,10 @@ Entrorove applies only to the task for which it is selected; reading these instr
 3. Discover `capabilities`, then invoke `start` with the actual goal, task type, risk and scope facts. An enabled account returns a cloud choice before charging a model. Show that choice visibly using the host question tool. Confirmation calls its original callback; exit adopts the local route for this task. Never treat silence as permission, invent acceptance, or create both routes. Existing explicit authorization for this task persists.
    With cloud sandbox disabled, the IDE performs its own planning and continues the original API flow. Do not require a cloud model call or create a sandbox task to perform local work. The service freezes eligible member plans with `verificationMode: member-local` and `runnerKeyId: null`; successful original IDE execution and tests satisfy local acceptance. This mode comes from the stored account preference and enrolled scope, never a caller flag or an unavailable validator key. An already frozen independent plan keeps its original acceptance contract.
    When the model produces a task contract, preserve its `workType`, `risk`, `difficulty`, `crossModule`, `parallel`, `unclear`, `architectureContract`, optional `baselineRef`, and optional `interaction` as returned. Valid work types are `implementation`, `documentation`, `calculation`, `merge`, `review`, `decision`, and `diagnosis`. A `merge` requires a concrete `baselineRef` identifying the branch, tag, commit, or review baseline; keep that baseline unchanged through independent verification. A `decision` requires `interaction`, including a risk description for medium or high risk. Do not fill missing required fields by guessing.
-4. After real cloud acceptance, immediately display **云端任务 <taskNumber> · 已进入**. Preserve `taskNumber` verbatim: it is the homepage sandbox tab number. Keep its UUID `taskId` separately. Run the returned `cloud-watch`, show each real public event and its cursor, and continue the original accepted flow from status. A command log alone is insufficient. No accepted cloud task means no cloud ID or model-execution claim.
+4. After real cloud acceptance, immediately display the returned entering status in the task’s selected language, including its **taskNumber**. Preserve `taskNumber` verbatim: it is the homepage sandbox tab number. Keep its UUID `taskId` separately. Run the returned `cloud-watch`, show each real public event and its cursor, and continue the original accepted flow from status. A command log alone is insufficient. No accepted cloud task means no cloud ID or model-execution claim.
 5. For an accepted `flowId`, execute the returned `nextStep` with its required payload. Discover the schema before constructing input. An empty payload is valid only when that operation's schema allows it. Reconnect and refresh only the original flow. A changed snapshot is a binding failure to investigate; do not invent a fresh successful baseline, rebuild a flow to evade it, or erase the old failure. If a fresh scope proof returns `ENTROROVE_SCOPE_PLANNING_REASSESSMENT_REQUIRED` before plan freeze, follow its explicit `workflow-scope-reassess` recovery and retry the original complete request; a local reassessment or snapshot refresh alone does not renew the accepted gate. If the terminal flow truly owns a stale task slot, use the explicit `flow-abandon` lifecycle operation described below before routing the original task again.
 6. All governed mutations use the original authority: `local guarded-write`, `local guarded-delete`, `local guarded-move`, or the original frozen approved runner plan. Native patches, scripts, terminal writes, database mutations and unknown MCP operations must not substitute for the controlled entry. User-authorized task messages use the host's message tool and remain subject to host approval; sending a report does not change the flow or grant execution authority. **A failed gate or unknown outcome must never be replaced with another executor or reported as local success.** Query the original request read-only, repair the cause, and obtain the original flow's valid authority before proceeding. If the original scope challenge preparation is absent from authenticated status, `scope-amend` may use the discovered `scope-challenge-retire` lifecycle operation. The server validates the same approved proposal and receiver, atomically fences only an unadmitted challenge, and records a signed retirement without executing that challenge. Recover and acknowledge the original retirement result with GET before a fresh challenge attempt; retain both requests and all failures. An admitted request, issued nonce, scope application or mutation has no missing-challenge retirement path. An uncertain retirement itself permits only its original GET.
-   For a member scope, follow a returned `localAction` before submitting execution evidence. `mutation-connect` obtains only the original task's limited editing pass; it keeps unresolved loader files and project configuration read only. After actual writes, refresh the original scope and run `mutation-settle`. Use the returned `previousPassId` for further edits. In a signed member-local plan, `workflow-observe-step` runs the original approved command and tests without a validator private key. A server-signed `localAcceptance` advances local dependencies; a failed test does not. Preserve the raw observation and its absent independent receipt. See [IDE-EXECUTION.md](IDE-EXECUTION.md#local-ide-acceptance).
+   For a member scope, follow a returned `localAction` before submitting execution evidence. `mutation-connect` obtains only the original task's limited editing pass. Its non-structural modify role requires known target source imports, preserves source imports and public contracts, and keeps unresolved origins, other observed dependencies and project configuration read only. Build scripts, macros and generated sources can remain opaque; source observations and this editing role never prove a complete compiled dependency graph or successful tests. After actual writes, refresh the original scope and run `mutation-settle`. Use the returned `previousPassId` for further edits. In a signed member-local plan, `workflow-observe-step` runs the original frozen command and tests without a validator private key. A server-signed `localAcceptance` advances local dependencies; a failed test does not. A frozen independent plan retains its independent validation requirement. Preserve the raw observation and its absent independent receipt. See [IDE-EXECUTION.md](IDE-EXECUTION.md#local-ide-acceptance).
 7. Read [REUSE-DISCIPLINE.md](REUSE-DISCIPLINE.md) when modifying an existing system. The comparison baseline is the existing implementation in that same repository. It never means another project, another account, or copying external systems.
    Never overwrite a newer package with older bytes, relabel an old archive as new, or roll back because the current state is uncertain. Package identity/version checks and immutable historical byte observations run in the guarded entries. A refusal requires preserved inputs and diagnosis; a `force`, `rollback`, timestamp or filename is not evidence. Intentional rollback uses the original independently signed merge rollback authorization, transaction journal, exact current/restore hashes and fresh original mutation pass. Preserve old failures, receipts and unknown effects; a successful rollback never makes the failed operation successful.
    **Before preparing or writing any UI implementation, read [DESIGN-GATES.md](DESIGN-GATES.md).** Record the whole-site flow first, fetch current mainstream layout references and the specified framework's official rules, create actual mockups or prototypes using the host image/design tool, and show them to the user. Respect their choice of visual format; a prototype is a valid approval baseline. Obtain the original persisted design confirmation before UI code preparation. Carry that exact design approval through the original scope, plan and mutation gates. Neither a caller flag nor a text-only description substitutes for this sequence. Finish real functional tests, actual browser interaction/layout/style checks and original user visual acceptance before delivery. Keep Entrorove unchanged in every language.

package/cloud-locale.d.mts

@@ -0,0 +1,7 @@
+export type CloudOutputLocale = 'zh' | 'en'
+export function cloudOutputLocale(value: unknown): CloudOutputLocale | undefined
+export function cloudMessage(key: string, locale?: CloudOutputLocale): string
+export function cloudProseMatches(text: unknown, locale: CloudOutputLocale): boolean
+export function cloudEventDisplay(value: { content: string; kind?: string; metadata?: Record<string, unknown> }, locale: CloudOutputLocale): {
+  content: string; summary?: string; sourceContent?: string; sourceSummary?: string; sourceLocale: CloudOutputLocale | 'unknown'
+}

package/cloud-locale.mjs

@@ -0,0 +1,59 @@
+const copy = {
+  choice: ['是否启用云端沙箱执行思考规划？', 'Use the cloud sandbox to plan this task?'],
+  use: ['确认', 'Use cloud sandbox'], local: ['退出，采用本地方案', 'Continue locally'],
+  useHint: ['为当前任务创建云端思考规划并显示真实进度', 'Plan this task in the cloud and show actual progress'],
+  localHint: ['继续当前任务，不改变账号开关', 'Continue this task without changing the account preference'],
+  risk: ['这是当前任务的执行位置选择，不改变账号级云端沙箱开关。', 'This chooses the execution location for this task without changing the account preference.'],
+  fallback: ['是否启用云端沙箱执行思考规划？\n1. 确认：当前任务使用云端沙箱\n2. 退出：自动采用本地方案，继续当前任务',
+    'Use the cloud sandbox to plan this task?\n1. Use cloud sandbox for this task\n2. Continue this task locally'],
+  skipped: ['已退出云端沙箱，采用本地方案继续当前任务。', 'Continue this task locally without entering the cloud sandbox.'],
+  enter: ['正在进入云端沙箱', 'Entering the cloud sandbox'], accepted: ['已进入', 'Accepted'],
+  task: ['云端任务', 'Cloud task'], output: ['云端沙箱输出完毕；实际验证状态以任务回执为准。', 'Cloud sandbox output is available; verification remains determined by the actual task receipt.'],
+  exit: ['云端沙箱正在退出本次进度订阅', 'Closing this cloud progress subscription'],
+  waiting: ['云端沙箱仍在执行，下次从当前进度继续读取', 'Cloud execution continues; resume reading from the current progress cursor'],
+  source: ['原始输出（保留来源，未作翻译）', 'Original output (source preserved; not translated)'],
+  sourceDetails: ['原始详情（未翻译）', 'Original details (not translated)'],
+  event: ['云端进度已更新；原文保留在来源详情。', 'Cloud progress updated; the original text is preserved in source details.'],
+  failed: ['云端任务失败；原始诊断保留在来源详情。', 'Cloud task failed; the original diagnostic is preserved in source details.'],
+  keepAlive: ['智能执行中，请勿关闭！', 'Execution in progress. Please keep this window open.'],
+}
+const events = {
+  'Cloud task accepted.': ['任务已进入', 'Task accepted'],
+  'Cloud workflow started.': ['云端沙箱任务已分配', 'Cloud sandbox task allocated'],
+  'Cloud model classification started.': ['云端沙箱正在分析任务', 'Cloud sandbox is analyzing the task'],
+  'Task classification completed.': ['云端沙箱分析已返回', 'Cloud sandbox analysis returned'],
+  'Workflow completed with verified evidence.': ['任务已核验', 'Task verified'],
+  'Workflow is blocked.': ['流程已阻断', 'Workflow blocked'],
+  'Workflow is incomplete.': ['流程待补全', 'Workflow incomplete'],
+  'Workflow failed.': ['流程执行失败', 'Workflow failed'],
+  'Workflow reported its result; verification is pending.': ['结果已返回，仍待实际核验', 'Result reported; actual verification remains pending'],
+  'Workflow is waiting for an explicit decision.': ['等待你明确确认', 'Awaiting your explicit decision'],
+  'Original cloud task stopped.': ['原云端任务已停止', 'Original cloud task stopped'],
+  'Model returned prose outside the frozen cloud output language': ['模型未按本任务固定语种返回说明', 'Model prose did not match the frozen task output language'],
+}
+export function cloudOutputLocale(value) {
+  if (value === undefined || value === null) return undefined;
+  if (!['zh', 'en'].includes(value)) throw new Error('Invalid frozen cloud output locale');
+  return value;
+}
+export function cloudMessage(key, locale) {
+  if (!Object.hasOwn(copy, key)) throw new Error('Unknown cloud presentation message');
+  return copy[key][locale === 'en' ? 1 : 0];
+}
+export function cloudProseMatches(text, locale) {
+  return typeof text === 'string' && (locale === 'en' ? !/\p{Script=Han}/u.test(text) : /\p{Script=Han}/u.test(text));
+}
+export function cloudEventDisplay(value, locale) {
+  const metadata = value.metadata ?? {}, content = value.content ?? '';
+  const fixed = Object.hasOwn(events, content) ? events[content][locale === 'en' ? 1 : 0]
+    : content.trim() === copy.keepAlive[0] ? cloudMessage('keepAlive', locale) : undefined;
+  const sourceContent = !fixed && !cloudProseMatches(content, locale) ? content : undefined;
+  const displayed = fixed ?? (sourceContent ? cloudMessage(value.kind === 'error' ? 'failed' : 'event', locale) : content);
+  const originalSummary = typeof metadata.summary === 'string' ? metadata.summary : undefined;
+  const translated = metadata.summaryTranslations?.[locale];
+  const candidate = typeof translated === 'string' && translated.trim() ? translated : originalSummary;
+  const summary = candidate && cloudProseMatches(candidate, locale) ? candidate : undefined;
+  return { content: displayed, ...(summary ? { summary } : {}),
+    ...(sourceContent ? { sourceContent } : {}), ...(!summary && originalSummary ? { sourceSummary: originalSummary } : {}),
+    sourceLocale: cloudOutputLocale(metadata.outputLocale) ?? 'unknown' };
+}

package/cloud-task-client.mjs

@@ -5,6 +5,7 @@ import { displayIdeEvent, ideClientHeaders, ideTaskIdentity } from './ide-presen
 import { verifyAutomaticFeedback } from './automatic-feedback-client.mjs';
 import { sandboxTaskNumber } from './task-identity.mjs';
 import { prepareCloudImages } from './cloud-task-images.mjs';
+import { cloudEventDisplay, cloudMessage, cloudOutputLocale } from './cloud-locale.mjs';
 
 const CLOUD_TASK_SCHEMA = 'entrorove.cloud-task/1.0';
 const CLOUD_STATUS_SCHEMA = 'entrorove.cloud-status/1.0';
@@ -42,9 +43,11 @@ function validateInput(input) {
   if (input.images !== undefined && (!Array.isArray(input.images) || input.images.length > 4)) {
     throw new Error('cloud-task images must be an array of at most four images');
   }
+  if (input.outputLocale !== undefined && !['zh', 'en'].includes(input.outputLocale)) throw new Error('cloud-task outputLocale must be zh or en');
+  const outputLocale = cloudOutputLocale(input.outputLocale);
   return { goal: input.goal, ...(input.ideTaskId === undefined ? {} : { ideTaskId: input.ideTaskId }),
     ...(input.images === undefined ? {} : { images: input.images }),
-    ...(input.task === undefined ? {} : { task: input.task }) };
+    ...(input.task === undefined ? {} : { task: input.task }), ...(outputLocale ? { outputLocale } : {}) };
 }
 
 function validateDependencies(dependencies) {
@@ -64,18 +67,19 @@ function authenticatedHeaders(token, headers = {}) {
 }
 
 export function sandboxChoiceInteraction(id, task = {}) {
+  const locale = cloudOutputLocale(task.outputLocale);
   return {
     schemaVersion: 'confirm.interaction/1.0', requestId: id, type: 'choice',
-    question: '是否启用云端沙箱执行思考规划？',
+    question: cloudMessage('choice', locale),
     options: [
-      { id: 'use', label: '确认', hint: '为当前任务创建云端思考规划并显示真实进度' },
-      { id: 'local', label: '退出，采用本地方案', hint: '继续当前任务，不改变账号开关' },
+      { id: 'use', label: cloudMessage('use', locale), hint: cloudMessage('useHint', locale) },
+      { id: 'local', label: cloudMessage('local', locale), hint: cloudMessage('localHint', locale) },
     ],
     default: 'local', timeout: null, timeoutAction: 'local', risk: 'low',
-    riskDescription: '这是当前任务的执行位置选择，不改变账号级云端沙箱开关。',
+    riskDescription: cloudMessage('risk', locale),
     rememberable: false, memoryKey: '',
     callback: { operation: 'cloud-task', payload: { ...task } },
-    chatFallback: '是否启用云端沙箱执行思考规划？\n1. 确认：当前任务使用云端沙箱\n2. 退出：自动采用本地方案，继续当前任务',
+    chatFallback: cloudMessage('fallback', locale),
   };
 }
 
@@ -103,9 +107,9 @@ export async function runCloudTask(input, dependencies) {
     task, interaction: sandboxChoiceInteraction(id,task),
   });
   if (choice === 'local') return envelope(task, 'skipped', {
-    reason: 'task', executionIsolation: 'local', message: '已退出云端沙箱，采用本地方案继续当前任务。',
+    reason: 'task', executionIsolation: 'local', message: cloudMessage('skipped', task.outputLocale),
     continuation: { goal: task.goal,...(task.ideTaskId ? { ideTaskId: task.ideTaskId } : {}),
-      ...(task.images === undefined ? {} : { images: task.images }) },
+      ...(task.images === undefined ? {} : { images: task.images }), ...(task.outputLocale ? { outputLocale: task.outputLocale } : {}) },
   });
 
   if (task.images !== undefined) task.images = await prepareCloudImages(task.images);
@@ -115,7 +119,7 @@ export async function runCloudTask(input, dependencies) {
   const metadata = { kind: 'remote', operation: 'cloud-task', requestId: id };
   await appendInvocation({ ...metadata, event: 'started' }, dependencies.home);
   displayIdeEvent({ schemaVersion: 'entrorove.ide-event/1.0',requestId: id,kind: 'status',
-    phase: 'enter',message: '正在进入云端沙箱',separateLine: true },dependencies.onIdeEvent,{home:dependencies.home});
+    phase: 'enter',message: cloudMessage('enter', task.outputLocale),separateLine: true },dependencies.onIdeEvent,{home:dependencies.home});
   let response;
   try {
     response = await requestTransport(origin, '/api/cloud-task', {
@@ -142,9 +146,12 @@ export async function runCloudTask(input, dependencies) {
   if (!response.ok) {
     await appendInvocation({ ...metadata, event: response.status >= 500 ? 'outcome-unknown' : 'rejected' }, dependencies.home);
     const code = typeof result?.error === 'string' ? result.error : 'cloud-task-rejected';
-    return envelope(task, response.status === 403 ? 'blocked' : 'failed', { code, message: result?.message ?? code, httpStatus: response.status });
+    const rawMessage = typeof result?.message === 'string' ? result.message : code;
+    const display = task.outputLocale ? cloudEventDisplay({ kind: 'error',content: rawMessage },task.outputLocale) : undefined;
+    return envelope(task, response.status === 403 ? 'blocked' : 'failed', { code, message: display?.content ?? rawMessage,
+      ...(display?.sourceContent ? { source: { label: cloudMessage('source',task.outputLocale),content: display.sourceContent } } : {}), httpStatus: response.status });
   }
-  if (!result?.ok || typeof result.taskId !== 'string' || !UUID.test(result.taskId)
+  if (!result?.ok || result.outputLocale !== task.outputLocale || typeof result.taskId !== 'string' || !UUID.test(result.taskId)
     || result.taskNumber !== undefined && result.taskNumber !== sandboxTaskNumber(result.taskId)
     || result.afterId !== undefined && (typeof result.afterId !== 'string' || !/^[1-9][0-9]{0,18}$/u.test(result.afterId) || BigInt(result.afterId)>9223372036854775807n)) {
     await appendInvocation({ ...metadata, event: 'outcome-unknown' }, dependencies.home);
@@ -153,7 +160,7 @@ export async function runCloudTask(input, dependencies) {
   await appendInvocation({ ...metadata, event: 'completed' }, dependencies.home);
   const taskNumber = sandboxTaskNumber(result.taskId);
   const event = { schemaVersion: 'entrorove.ide-event/1.0',requestId: id,taskId: result.taskId,taskNumber,
-    kind: 'status',phase: 'accepted',message: `云端任务 ${taskNumber} · 已进入`,separateLine: true };
+    kind: 'status',phase: 'accepted',message: `${cloudMessage('task', task.outputLocale)} ${taskNumber} · ${cloudMessage('accepted', task.outputLocale)}`,separateLine: true };
   displayIdeEvent(event,dependencies.onIdeEvent,{home:dependencies.home});
   return envelope(task, 'started', { taskId: result.taskId,taskNumber,ideMessages: [event.message],
     taskStatus: typeof result.status === 'string' ? result.status : 'running',
@@ -164,7 +171,7 @@ export async function runCloudTask(input, dependencies) {
 function publicTask(task) {
   if (!task || typeof task !== 'object' || Array.isArray(task)) return null;
   const allowed = ['id', 'status', 'displayTitle', 'titleStatus', 'titleError', 'summary', 'ideTaskId',
-    'createdAt', 'updatedAt', 'completedAt'];
+    'createdAt', 'updatedAt', 'completedAt', 'outputLocale'];
   return Object.fromEntries(allowed.filter(key => task[key] !== undefined).map(key => [key, task[key]]));
 }
 
@@ -196,6 +203,7 @@ export async function queryCloudTask(taskId, dependencies) {
       code: typeof taskBody?.error === 'string' ? taskBody.error : taskResponse.status === 404 ? 'cloud-task-not-found' : 'cloud-status-unavailable', httpStatus: taskResponse.status };
   }
   const task = taskBody.task;
+  cloudOutputLocale(task.outputLocale);
   const feedback = taskBody.feedback ? verifyAutomaticFeedback(taskBody.feedback,taskBody.feedback.requestId) : undefined;
   let usage = [];
   let usageError;

package/cloud-watch-client.mjs

@@ -4,6 +4,7 @@ import { automaticFeedbackIdeEvent, cloudIdeEvent, displayIdeEvent, ideClientHea
 import { queryCloudTask } from './cloud-task-client.mjs';
 import { acknowledgeAutomaticFeedback } from './automatic-feedback-client.mjs';
 import { sandboxTaskNumber } from './task-identity.mjs';
+import { cloudMessage, cloudOutputLocale } from './cloud-locale.mjs';
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function inputOptions(input) {
@@ -24,6 +25,7 @@ export async function watchCloudTask(input, dependencies) {
   const controller = new AbortController(), deadline = setTimeout(() => controller.abort(),waitMs);
   const events = [], emit = event => { events.push(event); displayIdeEvent(event,dependencies.onIdeEvent,{home:dependencies.home}); };
   let afterId = options.afterId, taskStatus = 'running', outputAvailable = false, settled = false, flowId;
+  let outputLocale;
   try {
     const response = await fetch(`${trustedOrigin(dependencies.apiOrigin())}/api/cloud-sandbox/tasks/${taskId}/events`, {
       redirect: 'error',signal: controller.signal,headers: { authorization: `Bearer ${token}`,
@@ -38,6 +40,9 @@ export async function watchCloudTask(input, dependencies) {
       }
       if (!/^[1-9][0-9]{0,18}$/u.test(frame.id ?? '') || frame.data?.id !== frame.id) throw new Error('Invalid cloud event cursor');
       if (BigInt(frame.id) <= BigInt(afterId)) return;
+      const eventLocale = cloudOutputLocale(frame.data.metadata?.outputLocale);
+      if (outputLocale && eventLocale !== outputLocale) throw new Error('Cloud stream changed its original output language');
+      if (eventLocale) outputLocale = eventLocale;
       const event = cloudIdeEvent(frame.data,taskId); afterId = frame.id; emit(event);
       if (typeof frame.data.metadata?.flowId === 'string') flowId = frame.data.metadata.flowId;
       settled = event.phase === 'workflow' && ['reported','verified','blocked','failed'].includes(event.state);
@@ -48,15 +53,18 @@ export async function watchCloudTask(input, dependencies) {
     if (!controller.signal.aborted) throw cause;
   } finally { clearTimeout(deadline); controller.abort(); }
   if (outputAvailable) emit({ schemaVersion: 'entrorove.ide-event/1.0',taskId,kind: 'status',phase: 'output',
-    message: '云端沙箱输出完毕；实际验证状态以任务回执为准。',separateLine: true });
+    message: cloudMessage('output', outputLocale),separateLine: true });
   const current = await queryCloudTask(taskId,dependencies);
   if (current.status === 'observed') taskStatus = current.taskStatus;
+  const currentLocale = cloudOutputLocale(current.task?.outputLocale);
+  if (outputLocale && currentLocale !== outputLocale) throw new Error('Cloud status changed its original output language');
+  outputLocale = currentLocale ?? outputLocale;
   if (current.feedback) {
     current.feedback = await acknowledgeAutomaticFeedback(current.feedback,dependencies.apiOrigin(),token,ideClientHeaders());
-    emit({ ...automaticFeedbackIdeEvent(current.feedback),taskId,taskNumber:sandboxTaskNumber(taskId) });
+    emit({ ...automaticFeedbackIdeEvent(current.feedback, outputLocale),taskId,taskNumber:sandboxTaskNumber(taskId) });
   }
   emit({ schemaVersion: 'entrorove.ide-event/1.0',taskId,kind: 'status',phase: 'exit',
-    message: settled || taskStatus !== 'running' ? '云端沙箱正在退出本次进度订阅' : '云端沙箱仍在执行，下次从当前进度继续读取',separateLine: true });
+    message: cloudMessage(settled || taskStatus !== 'running' ? 'exit' : 'waiting', outputLocale),separateLine: true });
   return { schemaVersion: 'entrorove.cloud-watch/1.0',status: current.status,taskId,taskNumber: sandboxTaskNumber(taskId),taskStatus,afterId,outputAvailable,
     events,...(flowId ? { flowId } : {}),task: current.task,usage: current.usage,...(current.feedback ? { feedback: current.feedback } : {}),
     nextAction: taskStatus === 'running' && !settled ? { operation: 'cloud-watch',input: { taskId,afterId,waitMs } } : null };

package/design-lint.mjs

@@ -3,6 +3,7 @@ import postcss from 'postcss';
 import { parse as parseVue } from '@vue/compiler-sfc';
 import { designFail, validateDesignPolicy } from './design-policy.mjs';
 import { designUiAsset } from './design-ui.mjs';
+import { uniConditionalVariants } from './local-scope-uni-conditional.mjs';
 
 export { designUiCandidate } from './design-ui.mjs';
 const issue = (rule, detail) => ({ rule, detail });
@@ -65,7 +66,7 @@ function scriptIssues(source, name, rules) {
   walk(tree);
   return { found, imports };
 }
-export function designLint(name, source, rules) {
+function lintSource(name, source, rules) {
   if (designUiAsset(name)) return [];
   if (typeof source !== 'string' || Buffer.byteLength(source) > 2_097_152) designFail('LINT_LIMIT', 'UI lint requires bounded UTF-8 source');
   if (/\.(?:scss|sass|less|styl|wxml|wxss|axml|acss)$/i.test(name)) return [issue('unsupported-ui-language', name)];
@@ -85,10 +86,27 @@ export function designLint(name, source, rules) {
   if (styles.length) found.push(issue('central-style-source-required', name));
   return found;
 }
+export function designLint(name, source, rules) {
+  if (!/\.vue$/i.test(name)) return lintSource(name, source, rules);
+  if (typeof source !== 'string' || Buffer.byteLength(source) > 2_097_152) designFail('LINT_LIMIT', 'UI lint requires bounded UTF-8 source');
+  try {
+    const conditional = uniConditionalVariants(source, name);
+    if (!conditional.directives.length) return lintSource(name, source, rules);
+    return conditional.variants.flatMap(variant => variant.source.trim()
+      ? lintSource(name, variant.source, rules).map(problem => ({ ...problem, conditionalBranch: variant.key })) : []);
+  } catch (error) {
+    if (!error.code?.startsWith('ENTROROVE_')) throw error;
+    return [issue('vue-conditional', error.message)];
+  }
+}
 export function assertDesignLint(policy, name, before, after, approvedBefore = before) {
   validateDesignPolicy(policy);
   const retained = new Map();
-  const inspect = source => [...designLint(name, source, policy.rules), ...privateFieldIssues(source, name, policy)];
+  const inspect = source => {
+    const problems = [...designLint(name, source, policy.rules), ...privateFieldIssues(source, name, policy)];
+    if (problems.some(problem => problem.rule === 'vue-conditional')) designFail('LINT', 'Conditional UI source requires complete supported branch inspection');
+    return problems;
+  };
   const approved = new Map();
   for (const problem of inspect(approvedBefore)) { const key = JSON.stringify(problem); approved.set(key, (approved.get(key) ?? 0) + 1); }
   for (const problem of inspect(before)) { const key = JSON.stringify(problem); retained.set(key, Math.min((retained.get(key) ?? 0) + 1, approved.get(key) ?? 0)); }

package/ide-presentation.mjs

@@ -1,6 +1,7 @@
 const UUID = /^[0-9a-f-]{36}$/i;
 import { notifyIdeEvent } from './native-notification.mjs';
 import { sandboxTaskNumber } from './task-identity.mjs';
+import { cloudEventDisplay, cloudMessage, cloudOutputLocale } from './cloud-locale.mjs';
 export function ideClientHeaders(environment = process.env) {
   const ide = environment.ENTROROVE_IDE ?? (environment.CODEX_THREAD_ID ? 'Codex'
     : environment.CURSOR_TRACE_ID ? 'Cursor' : environment.CLAUDE_CODE_ENTRYPOINT ? 'Claude Code' : 'Entrorove CLI');
@@ -27,17 +28,23 @@ export function cloudIdeEvent(value, taskId) {
     throw new Error('Cloud event lost its original task identity');
   }
   const metadata = value.metadata ?? {};
+  const locale = cloudOutputLocale(metadata.outputLocale);
+  const displayed = locale ? cloudEventDisplay(value, locale) : undefined;
   let message = text(value.content), phase = String(metadata.stepId ?? 'workflow');
-  if (message === 'Cloud task accepted.') { message = `云端任务 ${sandboxTaskNumber(taskId)} · 已进入`; phase = 'accepted'; }
+  if (message === 'Cloud task accepted.') { message = `${cloudMessage('task', locale)} ${sandboxTaskNumber(taskId)} · ${cloudMessage('accepted', locale)}`; phase = 'accepted'; }
   else if (message === 'Cloud workflow started.') message = '云端沙箱任务已分配';
   else if (message === 'Cloud model classification started.') message = '云端沙箱正在思考中';
   else if (message === 'Task classification completed.') message = '云端沙箱思考正在输出';
+  if (displayed && phase !== 'accepted') message = displayed.content;
   const event = { schemaVersion: 'entrorove.ide-event/1.0',taskId,taskNumber: sandboxTaskNumber(taskId),eventId: value.id,kind: value.kind,
     state: metadata.state ?? 'running',phase,message,separateLine: true };
   if (metadata.requiresUserInput === true || phase === 'confirm' && event.state === 'pending') event.requiresConfirmation = true;
   if (metadata.errorCode === 'model-balance-insufficient') event.errorCode = metadata.errorCode;
   if (typeof metadata.summary === 'string' && metadata.summary !== value.content
-    && value.content !== 'Cloud model classification started.') event.detail = text(metadata.summary);
+    && value.content !== 'Cloud model classification started.') event.detail = text(displayed?.summary ?? (locale ? '' : metadata.summary));
+  if (displayed?.sourceContent || displayed?.sourceSummary) event.source = {
+    label: cloudMessage('source', locale), ...(displayed.sourceContent ? { content: text(displayed.sourceContent) } : {}),
+    ...(displayed.sourceSummary ? { summary: text(displayed.sourceSummary) } : {}), locale: displayed.sourceLocale };
   if (value.kind === 'notice' && metadata.url !== undefined) {
     let url;
     try { url = new URL(metadata.url); } catch { throw new Error('Cloud promotion link is invalid'); }
@@ -63,11 +70,15 @@ export function presentInvocationNotices(result, sink, notifications) {
   }
   return messages.length ? { ...result,ideMessages: messages } : result;
 }
-export function automaticFeedbackIdeEvent(feedback) {
+export function automaticFeedbackIdeEvent(feedback, outputLocale) {
   const disposition = feedback.evaluation.disposition;
   const status = disposition === 'good' ? '当前调用验证通过' : disposition === 'bad'
     ? '当前调用被阻断或验证失败' : '交付验证尚未完成，暂不评分';
+  const english = outputLocale === 'en';
+  const englishStatus = disposition === 'good' ? 'this invocation passed verification' : disposition === 'bad'
+    ? 'this invocation was blocked or failed verification' : 'delivery verification remains incomplete; no score is assigned';
   return { schemaVersion: 'entrorove.ide-event/1.0',requestId: feedback.requestId,receiptId: feedback.receiptId,
     kind: 'evaluation',phase: 'feedback',disposition,
-    message: `${feedback.acknowledgement?.stored === true ? '本次调用评价已回传至服务器' : '服务器已保存本次调用评价'}：${status}。`,separateLine: true };
+    message: english ? `${feedback.acknowledgement?.stored === true ? 'The server acknowledged this invocation evaluation' : 'The server saved this invocation evaluation'}: ${englishStatus}.`
+      : `${feedback.acknowledgement?.stored === true ? '本次调用评价已回传至服务器' : '服务器已保存本次调用评价'}：${status}。`,separateLine: true };
 }

package/local-archguard-components.mjs

@@ -1,6 +1,7 @@
-import { parse as parseVue, compileTemplate } from '@vue/compiler-sfc';
+import { parse as parseVue, parseCache, compileTemplate } from '@vue/compiler-sfc';
 import { parse as parseSvelte } from 'svelte/compiler';
 import { analyzeArchguardLanguage } from './local-archguard-language-ast.mjs';
+import { uniConditionalVariants } from './local-scope-uni-conditional.mjs';
 
 export function archguardComponentLanguage(path) {
   return new Map([['vue', 'vue'], ['svelte', 'svelte'], ['wxml', 'wxml']]).get(path.split('.').at(-1)) ?? null;
@@ -70,6 +71,7 @@ function addStyle(target, source, rules, content, base, lineOffsets, property =
 function vueSections(file) {
   const parsed = parseVue(file.content, { filename: file.path, sourceMap: false,
     templateParseOptions: { expressionPlugins: ['typescript'] } });
+  parseCache.clear();
   if (parsed.errors.length) return { errors: parsed.errors };
   const descriptor = parsed.descriptor;
   if (descriptor.customBlocks.length || descriptor.template?.lang) throw new Error('ARCH-AST-EMBEDDED-LANGUAGE-UNSUPPORTED');
@@ -137,11 +139,13 @@ function wxmlSections(file) {
     transformAssetUrls: false, compilerOptions: { comments: true } });
   return { template: compiled.ast, scripts: [], styles: [], errors: compiled.errors };
 }
-export function analyzeArchguardComponent(file, rules, analyzeScript) {
-  const language = archguardComponentLanguage(file.path); const lineOffsets = offsets(file.content);
-  const target = { selected: new Map(rules.filter(rule => rule.engine === 'ast').map(rule => [rule.id, { rule, locations: [] }])),
+function componentResult(rules) {
+  return { selected: new Map(rules.filter(rule => rule.engine === 'ast').map(rule => [rule.id, { rule, locations: [] }])),
     builtin: new Map(['no-eval', 'no-debug', 'no-inline-style', 'no-hardcoded-color', 'no-magic-number'].map(id => [id, []])),
     dependencies: [], maxFunctionLines: 0, maxNestingDepth: 0, animations: 0, transitions: 0, diagnostics: [] };
+}
+function analyzeComponentVariant(file, rules, analyzeScript) {
+  const language = archguardComponentLanguage(file.path), lineOffsets = offsets(file.content), target = componentResult(rules);
   try {
     let sections; let ranges;
     if (language === 'svelte') {
@@ -175,3 +179,26 @@ export function analyzeArchguardComponent(file, rules, analyzeScript) {
     target.diagnostics.push(syntaxError(error, language, lineOffsets)); return target;
   }
 }
+function unionLocations(left, right) {
+  return [...new Map([...left, ...right].map(item => [JSON.stringify(item), item])).values()];
+}
+export function analyzeArchguardComponent(file, rules, analyzeScript) {
+  if (archguardComponentLanguage(file.path) !== 'vue') return analyzeComponentVariant(file, rules, analyzeScript);
+  const target = componentResult(rules);
+  try {
+    const conditional = uniConditionalVariants(file.content, file.path);
+    if (!conditional.directives.length) return analyzeComponentVariant(file, rules, analyzeScript);
+    const inspected = new Set();
+    for (const variant of conditional.variants) {
+      if (!variant.source.trim() || inspected.has(variant.source)) continue;
+      inspected.add(variant.source);
+      const part = analyzeComponentVariant({ ...file, content: variant.source }, rules, analyzeScript);
+      for (const [id, locations] of part.builtin) target.builtin.set(id, unionLocations(target.builtin.get(id), locations));
+      for (const [id, selected] of part.selected) target.selected.get(id).locations = unionLocations(target.selected.get(id).locations, selected.locations);
+      for (const field of ['dependencies', 'diagnostics']) target[field] = unionLocations(target[field], part[field]);
+      for (const field of ['maxFunctionLines', 'maxNestingDepth', 'animations', 'transitions']) target[field] = Math.max(target[field], part[field]);
+    }
+    if (!inspected.size) throw new Error('Conditional component has no inspectable branch');
+  } catch (error) { target.diagnostics.push(syntaxError(error, 'uni-conditional', offsets(file.content))); }
+  return target;
+}

package/local-budget-reads.mjs

@@ -102,7 +102,7 @@ export async function readBudgetedProjectFile(input, target, options = {}) {
     const root = await fs.realpath(input.repositoryRoot);
     const sourcePath = options.sourcePath ?? path.relative(root, target).split(path.sep).join('/');
     const before = await fs.lstat(target, { bigint: true });
-    const result = await budgetReadBuffer({ ...binding, path: sourcePath }, { target });
+    const result = await budgetReadBuffer({ ...binding, path: sourcePath }, { target, verifyReadTarget: options.verifyReadTarget });
     const after = await fs.lstat(target, { bigint: true });
     if (!sameSourceStat(before, after)) fail('ENTROROVE_SCOPE_CHANGED', 'budgeted project source changed during its bound observation');
     projectBuffers.set(result.content, Object.freeze({ home: await fs.realpath(binding.home ?? os.homedir()),
@@ -110,7 +110,12 @@ export async function readBudgetedProjectFile(input, target, options = {}) {
     return options.encoding ? result.content.toString(options.encoding) : result.content;
   }
   const handle = await fs.open(target, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
-  try { if (!(await handle.stat()).isFile()) fail('ENTROROVE_FILE_INVALID', 'source must be a regular file'); return await handle.readFile(options.encoding ? { encoding: options.encoding } : undefined); }
+  try {
+    const descriptor = await handle.stat();
+    if (!descriptor.isFile()) fail('ENTROROVE_FILE_INVALID', 'source must be a regular file');
+    if (options.verifyReadTarget) await options.verifyReadTarget({ target: await fs.realpath(target), descriptor });
+    return await handle.readFile(options.encoding ? { encoding: options.encoding } : undefined);
+  }
   finally { await handle.close(); }
 }
 

package/local-budget.mjs

@@ -91,7 +91,7 @@ function assertReadAllowed(state, relative, tokens, now = Date.now()) {
   if (tokens > state.maxTokenEstimate - state.tokenEstimate) fail('ENTROROVE_BUDGET_EXHAUSTED', 'read token budget exhausted');
   if (now - Date.parse(state.startedAt) >= state.maxDurationMs) fail('ENTROROVE_BUDGET_EXHAUSTED', 'read duration budget exhausted');
 }
-async function readSource(location, state, relative, target, received) {
+async function readSource(location, state, relative, target, received, verifyReadTarget) {
   const binding = { home: location.home, repositoryRoot: location.root, flowId: location.flowId, path: relative };
   await assertBudgetHandoffReadAllowed(binding, state);
   const actualTarget = await budgetSourceTarget(location, relative, target);
@@ -101,6 +101,7 @@ async function readSource(location, state, relative, target, received) {
   try {
     const stat = await handle.stat(); if (!stat.isFile()) fail('ENTROROVE_FILE_INVALID', 'budget source must be a regular file');
     await assertDescriptorTarget(target, actualTarget, stat);
+    if (verifyReadTarget) await verifyReadTarget({ target: actualTarget, descriptor: stat });
     assertReadAllowed(state, relative, Math.ceil(stat.size / 4));
     const cap = state.enforced ? Math.max(0, (state.maxTokenEstimate - state.tokenEstimate) * 4) : Number.MAX_SAFE_INTEGER;
     const chunks = []; let size = 0;
@@ -131,7 +132,7 @@ export async function budgetReadBuffer(input, options = {}) {
       if (state.grant?.purpose === 'handoff-read') requireLiveBudget(budgetHandoffReadValidationState(state));
       else state = consumeBudgetRenewal({ state });
       const target = options.target ?? path.join(location.root, relative);
-      const content = await readSource(location, state, relative, target, received); const tokens = Math.ceil(content.length / 4);
+      const content = await readSource(location, state, relative, target, received, options.verifyReadTarget); const tokens = Math.ceil(content.length / 4);
       const updated = { ...state, files: state.files.includes(relative) ? state.files : [...state.files, relative], readCalls: state.readCalls + 1, tokenEstimate: state.tokenEstimate + tokens };
       const committed = await commitBudget(location, loaded, updated, 'budget-read', { path: relative, tokens, bytes: content.length,
         readId, renewedIntervals: (state.autoRenew?.renewalsUsed ?? 0) - (loaded.state.autoRenew?.renewalsUsed ?? 0), reason: state.autoRenew?.lastRenewalReason ?? null });

package/local-delegated-modify-analysis.mjs

@@ -3,6 +3,7 @@ import { parse as parseVue, parseCache } from '@vue/compiler-sfc';
 import { canonical } from './local-integrity.mjs';
 import { createScopeImportResolver } from './local-scope-import-expressions.mjs';
 import { isDynamicFunctionReference, isTypeOnlyReference } from './local-typescript-function-reference.mjs';
+import { uniConditionalVariants } from './local-scope-uni-conditional.mjs';
 
 const fail = () => { throw Object.assign(new Error('Preserved modification changed an existing definition, public contract, dependency, or unsupported source boundary'),
   { code: 'ENTROROVE_MUTATION_DELEGATION_CHANGE' }); };
@@ -216,17 +217,25 @@ function parts(path, content) {
 function retained(before, after) {
   for (const [key, count] of before) if ((after.get(key) ?? 0) < count) fail();
 }
+function compareSource(path, before, after) {
+  if (!before.trim() && !after.trim()) return;
+  const original = parts(path, before), candidate = parts(path, after);
+  if (canonical(original.metadata) !== canonical(candidate.metadata) || original.scripts.length !== candidate.scripts.length) fail();
+  for (let index = 0; index < original.scripts.length; index++) {
+    const a = scriptProjection(original.scripts[index]), b = scriptProjection(candidate.scripts[index]);
+    if (canonical(a.dependencies) !== canonical(b.dependencies) || canonical(a.public) !== canonical(b.public)) fail();
+    retained(a.definitions, b.definitions); retained(a.signatures, b.signatures); retained(b.unknown, a.unknown);
+  }
+}
 export function assertDelegatedSourceModification(input) {
   const { path, before, after } = input ?? {};
   if (typeof path !== 'string' || typeof before !== 'string' || typeof after !== 'string'
     || Buffer.byteLength(before) > 1_048_576 || Buffer.byteLength(after) > 1_048_576) fail();
   try {
-    const original = parts(path, before), candidate = parts(path, after);
-    if (canonical(original.metadata) !== canonical(candidate.metadata) || original.scripts.length !== candidate.scripts.length) fail();
-    for (let index = 0; index < original.scripts.length; index++) {
-      const a = scriptProjection(original.scripts[index]), b = scriptProjection(candidate.scripts[index]);
-      if (canonical(a.dependencies) !== canonical(b.dependencies) || canonical(a.public) !== canonical(b.public)) fail();
-      retained(a.definitions, b.definitions); retained(a.signatures, b.signatures); retained(b.unknown, a.unknown);
-    }
+    if (!/\.vue$/i.test(path)) return compareSource(path, before, after);
+    const original = uniConditionalVariants(before, path), candidate = uniConditionalVariants(after, path);
+    if (canonical(original.directives) !== canonical(candidate.directives)
+      || canonical(original.variants.map(value => value.key)) !== canonical(candidate.variants.map(value => value.key))) fail();
+    for (let index = 0; index < original.variants.length; index++) compareSource(path, original.variants[index].source, candidate.variants[index].source);
   } catch { fail(); }
 }