evolcore 0.0.24 → 0.0.26

package/dist/stats/billing.js

@@ -5,6 +5,7 @@
 import fs from 'fs';
 import path from 'path';
 import { getPackageRoot } from '../paths.js';
+import { parseModelId, stripContextWindowSuffix } from '../core/model/context-window-suffix.js';
 // 模型参数缓存（进程内，5 分钟 TTL）
 let _parameterCache = null;
 let _parameterCacheTs = 0;
@@ -79,21 +80,36 @@ function loadPrices(evolcoreHome) {
     _priceCacheTs = now;
     return _priceCache;
 }
+/**
+ * 按优先级列出一个模型 ID 的查表候选键。
+ *
+ * 上下文窗口变体（`claude-opus-5[1m]`）与基础模型同价，价表只需一条基础条目；
+ * 但仍先试精确匹配，好让用户能给某个变体单独定价。
+ */
+export function modelLookupKeys(evolcoreHome, model) {
+    const keys = [];
+    const push = (key) => { if (key && !keys.includes(key))
+        keys.push(key); };
+    push(model);
+    push(resolveCanonicalModel(evolcoreHome, model));
+    const base = stripContextWindowSuffix(model);
+    if (base !== model) {
+        push(base);
+        push(resolveCanonicalModel(evolcoreHome, base));
+    }
+    return keys;
+}
 /** 取 model 在 ts 时刻生效的价格行（effective_from <= ts 中最新的一条）。
- *  精确匹配失败时，通过 model-aliases.jsonl 映射到规范 ID 再查一次。 */
+ *  精确匹配失败时，依次回落到 alias 规范 ID 和去掉窗口后缀的基础 ID。 */
 export function resolvePriceRow(evolcoreHome, model, ts) {
     const prices = loadPrices(evolcoreHome);
-    let candidates = prices.filter(p => p.model === model && p.effective_from <= ts);
-    if (!candidates.length) {
-        // fallback: alias → canonical
-        const canonical = resolveCanonicalModel(evolcoreHome, model);
-        if (canonical !== model) {
-            candidates = prices.filter(p => p.model === canonical && p.effective_from <= ts);
+    for (const key of modelLookupKeys(evolcoreHome, model)) {
+        const candidates = prices.filter(p => p.model === key && p.effective_from <= ts);
+        if (candidates.length) {
+            return candidates.reduce((a, b) => a.effective_from >= b.effective_from ? a : b);
         }
     }
-    if (!candidates.length)
-        return null;
-    return candidates.reduce((a, b) => a.effective_from >= b.effective_from ? a : b);
+    return null;
 }
 export const BILLING_FNS = {
     // 通用 per-token（Claude / OpenAI 兼容 / Kimi / MiniMax）
@@ -164,14 +180,24 @@ function loadSpecs(evolcoreHome) {
     _specCacheTs = now;
     return _specCache;
 }
-/** 取模型在 ts 时刻的能力参数。找不到时返回默认值。 */
+/** 取模型在 ts 时刻的能力参数。找不到时返回默认值。
+ *  带窗口后缀的 ID 复用基础模型的参数行，但窗口由后缀决定（网关的权威声明）。 */
 export function resolveModelSpec(evolcoreHome, model, ts) {
     const specs = loadSpecs(evolcoreHome);
     const t = ts ?? Date.now();
-    const candidates = specs.filter(s => s.model === model && s.effective_from <= t);
-    if (candidates.length) {
-        return candidates.reduce((a, b) => a.effective_from >= b.effective_from ? a : b);
+    const suffixWindow = parseModelId(model).contextWindow;
+    for (const key of modelLookupKeys(evolcoreHome, model)) {
+        const candidates = specs.filter(s => s.model === key && s.effective_from <= t);
+        if (!candidates.length)
+            continue;
+        const row = candidates.reduce((a, b) => a.effective_from >= b.effective_from ? a : b);
+        if (suffixWindow === undefined || suffixWindow === row.context_window)
+            return row;
+        // 后缀声明的窗口覆盖基础行，输入上限按原行的预留比例等比缩放。
+        const ratio = row.context_window > 0 ? row.max_input_tokens / row.context_window : 0.9;
+        return { ...row, model, context_window: suffixWindow, max_input_tokens: Math.floor(suffixWindow * ratio) };
     }
     // 默认值
-    return { model, effective_from: 0, context_window: 200000, max_input_tokens: 180000, max_output_tokens: 8192 };
+    const contextWindow = suffixWindow ?? 200000;
+    return { model, effective_from: 0, context_window: contextWindow, max_input_tokens: Math.floor(contextWindow * 0.9), max_output_tokens: 8192 };
 }

package/dist/stats/price-resolver.js

@@ -2,7 +2,7 @@
  * price-resolver.ts — 统一价格解析逻辑，支持官方价格和网关价格。
  * 供 writer.ts 写入时调用，供 rebuild 命令回填历史数据。
  */
-import { resolvePriceRow, BILLING_FNS } from './billing.js';
+import { resolvePriceRow, modelLookupKeys, BILLING_FNS } from './billing.js';
 import fs from 'fs';
 import path from 'path';
 /** Keep wire/log metadata readable while preserving full precision in storage. */
@@ -44,10 +44,28 @@ function loadGatewayPrices(evolcoreHome) {
  */
 function resolveGatewayPriceRow(evolcoreHome, model, ts) {
     const prices = loadGatewayPrices(evolcoreHome);
-    const candidates = prices.filter(p => p.model === model && p.effective_from <= ts);
-    if (!candidates.length)
+    // 精确匹配优先（允许给某个窗口变体单独定价），再回落到基础 ID。
+    for (const key of modelLookupKeys(evolcoreHome, model)) {
+        const candidates = prices.filter(p => p.model === key && p.effective_from <= ts);
+        if (candidates.length) {
+            return candidates.reduce((a, b) => a.effective_from >= b.effective_from ? a : b);
+        }
+    }
+    return null;
+}
+/**
+ * 从网关价格 Map 里取价：Map 的键是网关原样下发的 ID（可能带 `[1m]` 后缀），
+ * 而 usage 事件记录的可能是基础 ID，反之亦然——两侧都要按候选键链匹配。
+ */
+function pickGatewayQuad(evolcoreHome, map, model) {
+    if (!map)
         return null;
-    return candidates.reduce((a, b) => a.effective_from >= b.effective_from ? a : b);
+    for (const key of modelLookupKeys(evolcoreHome, model)) {
+        const quad = map.get(key);
+        if (quad)
+            return quad;
+    }
+    return null;
 }
 /**
  * 从 PriceQuad 构造一个符合 billing.ts 规范的 PriceRecord。
@@ -80,9 +98,9 @@ export function resolvePrices(evolcoreHome, event, gatewayPricing) {
     // ── 1. 官方价格（Official Price）──────────────────────────────────────────
     let officialCost = null;
     // 优先级 1: 网关接口返回的 pricing 字段
-    if (gatewayPricing?.official.has(event.model)) {
-        const quad = gatewayPricing.official.get(event.model);
-        const priceRow = priceQuadToRecord(event.model, event.ts, quad, event.billing_fn);
+    const officialQuad = pickGatewayQuad(evolcoreHome, gatewayPricing?.official, event.model);
+    if (officialQuad) {
+        const priceRow = priceQuadToRecord(event.model, event.ts, officialQuad, event.billing_fn);
         const fn = BILLING_FNS[event.billing_fn];
         if (fn) {
             officialCost = fn(event, priceRow);
@@ -109,9 +127,9 @@ export function resolvePrices(evolcoreHome, event, gatewayPricing) {
         }
     }
     // 优先级 2: 网关接口返回的 effective_pricing 字段
-    if (!gatewayCost && gatewayPricing?.gateway.has(event.model)) {
-        const quad = gatewayPricing.gateway.get(event.model);
-        const priceRow = priceQuadToRecord(event.model, event.ts, quad, event.billing_fn);
+    const gatewayQuad = gatewayCost ? null : pickGatewayQuad(evolcoreHome, gatewayPricing?.gateway, event.model);
+    if (gatewayQuad) {
+        const priceRow = priceQuadToRecord(event.model, event.ts, gatewayQuad, event.billing_fn);
         const fn = BILLING_FNS[event.billing_fn];
         if (fn) {
             gatewayCost = fn(event, priceRow);

package/dist/utils/avatar-upload.js

@@ -1,12 +1,19 @@
 import fs from 'fs';
-import os from 'os';
-import path from 'path';
 import crypto from 'crypto';
+import dns from 'dns/promises';
+import net from 'net';
 import { agentmdGet, agentmdPut, updateAgentMdFrontmatterAvatar } from '../aun/aid/agentmd.js';
 import { storageRm, storageUpload } from '../aun/storage/index.js';
 import { logger } from './logger.js';
 import { validateImage } from './media-cache.js';
 const MAX_AVATAR_BYTES = 500 * 1024;
+const MIN_AVATAR_DIMENSION = 128;
+const MAX_AVATAR_DIMENSION = 2048;
+const MIN_AVATAR_RATIO = 0.8;
+const MAX_AVATAR_RATIO = 1.25;
+const MAX_AVATAR_REDIRECTS = 3;
+const AVATAR_DOWNLOAD_TIMEOUT_MS = 10_000;
+const AVATAR_DNS_TIMEOUT_MS = 2_000;
 const ALLOWED_AVATAR_MIMES = new Set(['image/png', 'image/jpeg', 'image/webp']);
 const MIME_EXT = {
     'image/png': 'png',
@@ -64,16 +71,230 @@ export async function uploadAvatar(aid, dataUrl, opts) {
     const parsed = parseAvatarDataUrl(dataUrl);
     if ('ok' in parsed)
         return parsed;
-    const validated = await validateImage(parsed.buffer, {
-        maxSize: MAX_AVATAR_BYTES,
-        allowedMimes: ALLOWED_AVATAR_MIMES,
-    });
-    if (validated.mime === null) {
-        return fail(`头像格式验证失败：${validated.reason}`, 'INVALID_ARGS');
-    }
+    const validated = await validateAvatarBuffer(parsed.buffer);
+    if (!('dimensions' in validated))
+        return validated;
     if (validated.mime !== parsed.mime) {
         return fail(`头像格式验证失败：声明 ${parsed.mime}，实际 ${validated.mime}`, 'INVALID_ARGS');
     }
+    return uploadValidatedAvatar(aid, parsed.buffer, validated.mime, validated.dimensions, opts);
+}
+function parseJpegDimensions(buffer) {
+    let offset = 2;
+    while (offset + 3 < buffer.length) {
+        if (buffer[offset] !== 0xff) {
+            offset++;
+            continue;
+        }
+        while (offset < buffer.length && buffer[offset] === 0xff)
+            offset++;
+        if (offset >= buffer.length)
+            return undefined;
+        const marker = buffer[offset++];
+        if (marker === 0xd8 || marker === 0xd9 || (marker >= 0xd0 && marker <= 0xd7))
+            continue;
+        if (offset + 1 >= buffer.length)
+            return undefined;
+        const segmentLength = buffer.readUInt16BE(offset);
+        if (segmentLength < 2 || offset + segmentLength > buffer.length)
+            return undefined;
+        const isSof = (marker >= 0xc0 && marker <= 0xc3)
+            || (marker >= 0xc5 && marker <= 0xc7)
+            || (marker >= 0xc9 && marker <= 0xcb)
+            || (marker >= 0xcd && marker <= 0xcf);
+        if (isSof && segmentLength >= 7) {
+            const height = buffer.readUInt16BE(offset + 3);
+            const width = buffer.readUInt16BE(offset + 5);
+            return { width, height };
+        }
+        offset += segmentLength;
+    }
+    return undefined;
+}
+function parseWebpDimensions(buffer) {
+    if (buffer.length < 16 || buffer.toString('ascii', 0, 4) !== 'RIFF' || buffer.toString('ascii', 8, 12) !== 'WEBP')
+        return undefined;
+    const chunk = buffer.toString('ascii', 12, 16);
+    if (chunk === 'VP8X' && buffer.length >= 30) {
+        const width = 1 + buffer[24] + (buffer[25] << 8) + (buffer[26] << 16);
+        const height = 1 + buffer[27] + (buffer[28] << 8) + (buffer[29] << 16);
+        return { width, height };
+    }
+    if (chunk === 'VP8L' && buffer.length >= 25 && buffer[20] === 0x2f) {
+        const bits = buffer[21] | (buffer[22] << 8) | (buffer[23] << 16) | (buffer[24] << 24);
+        const width = 1 + (bits & 0x3fff);
+        const height = 1 + ((bits >>> 14) & 0x3fff);
+        return { width, height };
+    }
+    if (chunk === 'VP8 ' && buffer.length >= 30) {
+        const frame = buffer.indexOf(Buffer.from([0x9d, 0x01, 0x2a]), 20);
+        if (frame >= 0 && frame + 7 < buffer.length) {
+            return { width: buffer.readUInt16LE(frame + 3) & 0x3fff, height: buffer.readUInt16LE(frame + 5) & 0x3fff };
+        }
+    }
+    return undefined;
+}
+function parseAvatarDimensions(buffer, mime) {
+    try {
+        if (mime === 'image/png' && buffer.length >= 24
+            && buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+            return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
+        }
+        if (mime === 'image/jpeg' && buffer.length >= 4 && buffer[0] === 0xff && buffer[1] === 0xd8)
+            return parseJpegDimensions(buffer);
+        if (mime === 'image/webp')
+            return parseWebpDimensions(buffer);
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function validateAvatarDimensions(buffer, mime) {
+    const dimensions = parseAvatarDimensions(buffer, mime);
+    if (!dimensions || !Number.isSafeInteger(dimensions.width) || !Number.isSafeInteger(dimensions.height)
+        || dimensions.width < MIN_AVATAR_DIMENSION || dimensions.height < MIN_AVATAR_DIMENSION
+        || dimensions.width > MAX_AVATAR_DIMENSION || dimensions.height > MAX_AVATAR_DIMENSION) {
+        return fail(`头像分辨率必须在 ${MIN_AVATAR_DIMENSION}x${MIN_AVATAR_DIMENSION} 至 ${MAX_AVATAR_DIMENSION}x${MAX_AVATAR_DIMENSION} 之间`, 'INVALID_ARGS');
+    }
+    const aspectRatio = dimensions.width / dimensions.height;
+    if (aspectRatio < MIN_AVATAR_RATIO || aspectRatio > MAX_AVATAR_RATIO) {
+        return fail(`头像宽高比必须在 ${MIN_AVATAR_RATIO} 至 ${MAX_AVATAR_RATIO} 之间（当前: ${aspectRatio.toFixed(3)}）`, 'INVALID_ARGS');
+    }
+    return dimensions;
+}
+function isPrivateAddress(address) {
+    if (net.isIPv4(address)) {
+        const [a, b] = address.split('.').map(Number);
+        return a === 0 || a === 10 || a === 127 || (a === 169 && b === 254)
+            || (a === 100 && b >= 64 && b <= 127) || (a === 172 && b >= 16 && b <= 31)
+            || (a === 192 && (b === 0 || b === 168)) || (a === 198 && (b === 18 || b === 19))
+            || a >= 224;
+    }
+    if (net.isIPv6(address)) {
+        const normalized = address.toLowerCase();
+        const mapped = normalized.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/)?.[1];
+        if (mapped)
+            return isPrivateAddress(mapped);
+        return normalized === '::1' || normalized === '::' || normalized.startsWith('fc')
+            || normalized.startsWith('fd') || normalized.startsWith('fe8') || normalized.startsWith('fe9')
+            || normalized.startsWith('fea') || normalized.startsWith('feb') || normalized.startsWith('ff');
+    }
+    return false;
+}
+async function validateAvatarUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return { ok: false, reason: '头像 URL 无效' };
+    }
+    if (parsed.protocol !== 'https:')
+        return { ok: false, reason: '头像 URL 仅支持 HTTPS' };
+    if (!parsed.hostname)
+        return { ok: false, reason: '头像 URL 缺少主机名' };
+    if (parsed.username || parsed.password)
+        return { ok: false, reason: '头像 URL 不允许携带认证信息' };
+    if (parsed.port && parsed.port !== '443')
+        return { ok: false, reason: '头像 URL 仅支持 HTTPS 默认端口' };
+    const hostname = parsed.hostname.replace(/^\[|\]$/g, '');
+    if (isPrivateAddress(hostname))
+        return { ok: false, reason: '头像 URL 指向受限地址' };
+    let dnsTimer;
+    try {
+        const addresses = await Promise.race([
+            dns.lookup(hostname, { all: true, verbatim: true }),
+            new Promise((_, reject) => { dnsTimer = setTimeout(() => reject(new Error('DNS lookup timeout')), AVATAR_DNS_TIMEOUT_MS); }),
+        ]);
+        if (dnsTimer)
+            clearTimeout(dnsTimer);
+        if (!addresses.length || addresses.some(({ address }) => isPrivateAddress(address))) {
+            return { ok: false, reason: '头像 URL 指向受限地址' };
+        }
+    }
+    catch {
+        if (dnsTimer)
+            clearTimeout(dnsTimer);
+        return { ok: false, reason: '头像 URL 主机名无法解析' };
+    }
+    return { ok: true, url: parsed };
+}
+async function downloadAvatarBuffer(sourceUrl) {
+    let current = sourceUrl;
+    for (let redirect = 0; redirect <= MAX_AVATAR_REDIRECTS; redirect++) {
+        const checked = await validateAvatarUrl(current);
+        if (!checked.ok)
+            return fail(checked.reason, 'INVALID_ARGS');
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), AVATAR_DOWNLOAD_TIMEOUT_MS);
+        let response;
+        try {
+            response = await fetch(checked.url, {
+                redirect: 'manual',
+                headers: { accept: 'image/png,image/jpeg,image/webp', 'accept-encoding': 'identity' },
+                signal: controller.signal,
+            });
+        }
+        catch (e) {
+            clearTimeout(timeout);
+            return fail(`头像 URL 下载失败: ${messageOf(e)}`, 'UPLOAD_FAILED');
+        }
+        if (response.status >= 300 && response.status < 400) {
+            const location = response.headers.get('location');
+            clearTimeout(timeout);
+            if (!location || redirect === MAX_AVATAR_REDIRECTS)
+                return fail('头像 URL 重定向次数过多或缺少目标', 'INVALID_ARGS');
+            try {
+                current = new URL(location, checked.url).toString();
+            }
+            catch {
+                return fail('头像 URL 重定向目标无效', 'INVALID_ARGS');
+            }
+            continue;
+        }
+        if (!response.ok) {
+            clearTimeout(timeout);
+            return fail(`头像 URL 返回 HTTP ${response.status}`, 'UPLOAD_FAILED');
+        }
+        const length = Number(response.headers.get('content-length') || 0);
+        if (length > MAX_AVATAR_BYTES) {
+            clearTimeout(timeout);
+            return fail('头像大小超过 500KB 限制', 'INVALID_ARGS');
+        }
+        if (!response.body) {
+            clearTimeout(timeout);
+            return fail('头像 URL 返回空响应', 'INVALID_ARGS');
+        }
+        const reader = response.body.getReader();
+        const chunks = [];
+        let total = 0;
+        try {
+            while (true) {
+                const part = await reader.read();
+                if (part.done)
+                    break;
+                const chunk = Buffer.from(part.value);
+                total += chunk.length;
+                if (total > MAX_AVATAR_BYTES) {
+                    await reader.cancel();
+                    return fail('头像大小超过 500KB 限制', 'INVALID_ARGS');
+                }
+                chunks.push(chunk);
+            }
+        }
+        catch (e) {
+            return fail(`头像 URL 下载失败: ${messageOf(e)}`, 'UPLOAD_FAILED');
+        }
+        finally {
+            clearTimeout(timeout);
+            reader.releaseLock();
+        }
+        return Buffer.concat(chunks, total);
+    }
+    return fail('头像 URL 重定向次数过多', 'INVALID_ARGS');
+}
+async function uploadValidatedAvatar(aid, buffer, mime, dimensions, opts) {
     let agentMd;
     try {
         agentMd = await agentmdGet(aid, { aunPath: opts?.aunPath });
@@ -81,21 +302,18 @@ export async function uploadAvatar(aid, dataUrl, opts) {
     catch (e) {
         return fail(`agent.md 不存在或无法读取: ${messageOf(e)}`, classifyAgentMdReadError(e));
     }
-    const ext = MIME_EXT[validated.mime] ?? 'img';
+    const ext = MIME_EXT[mime] ?? 'img';
     const objectKey = `shared/avatars/${crypto.randomUUID()}.${ext}`;
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'evolcore-avatar-'));
-    const tmpPath = path.join(tmpDir, `avatar.${ext}`);
+    const sha256 = crypto.createHash('sha256').update(buffer).digest('hex');
     let uploaded = false;
     try {
-        fs.writeFileSync(tmpPath, parsed.buffer);
-        const uploadedAvatar = await storageUpload(aid, tmpPath, objectKey, {
+        const uploadedAvatar = await storageUpload(aid, buffer, objectKey, {
             isPublic: true,
-            contentType: validated.mime,
+            contentType: mime,
             aunPath: opts?.aunPath,
         });
-        if (!uploadedAvatar.ok) {
+        if (!uploadedAvatar.ok)
             return fail(`上传到 AUN storage 失败: ${uploadedAvatar.error || 'unknown error'}`, 'UPLOAD_FAILED');
-        }
         uploaded = true;
         const publicUrl = uploadedAvatar.publicUrl ?? `https://${aid}/${uploadedAvatar.objectKey}`;
         const updated = updateAgentMdFrontmatterAvatar(agentMd, publicUrl);
@@ -107,17 +325,58 @@ export async function uploadAvatar(aid, dataUrl, opts) {
             return fail(`更新 agent.md 失败: ${messageOf(e)}`, 'UPLOAD_FAILED');
         }
         logger.info(`[avatar-upload] uploaded ${uploadedAvatar.objectKey} -> ${publicUrl}`);
-        return { ok: true, publicUrl, objectKey: uploadedAvatar.objectKey };
+        return {
+            ok: true,
+            publicUrl,
+            objectKey: uploadedAvatar.objectKey,
+            sha256,
+            mime,
+            width: dimensions.width,
+            height: dimensions.height,
+            aspectRatio: dimensions.width / dimensions.height,
+        };
     }
     catch (e) {
         if (uploaded)
             await cleanupUploadedAvatar(aid, objectKey, opts?.aunPath);
         return fail(messageOf(e), 'UPLOAD_FAILED');
     }
-    finally {
-        try {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-        catch { /* ignore */ }
+}
+async function validateAvatarBuffer(buffer) {
+    const validated = await validateImage(buffer, {
+        maxSize: MAX_AVATAR_BYTES,
+        allowedMimes: ALLOWED_AVATAR_MIMES,
+    });
+    if (validated.mime === null)
+        return fail(`头像格式验证失败：${validated.reason}`, 'INVALID_ARGS');
+    const dimensions = validateAvatarDimensions(buffer, validated.mime);
+    if ('ok' in dimensions)
+        return dimensions;
+    return { ok: true, mime: validated.mime, dimensions };
+}
+/** Upload an image file after validating its bytes and real MIME type. */
+export async function uploadAvatarFile(aid, filePath, opts) {
+    try {
+        const buffer = fs.readFileSync(filePath);
+        return await uploadAvatarBuffer(aid, buffer, opts);
     }
+    catch (e) {
+        return fail(`头像文件读取失败: ${messageOf(e)}`, 'NOT_FOUND');
+    }
+}
+/** Upload already-read image bytes; callers can use this after secure fd validation. */
+export async function uploadAvatarBuffer(aid, buffer, opts) {
+    const validated = await validateAvatarBuffer(buffer);
+    if (!('dimensions' in validated))
+        return validated;
+    return uploadValidatedAvatar(aid, buffer, validated.mime, validated.dimensions, opts);
+}
+/** Download an HTTPS image with redirect/SSRF/size guards, then upload it. */
+export async function uploadAvatarUrl(aid, url, opts) {
+    if (typeof url !== 'string' || !url.trim())
+        return fail('头像 URL 不能为空', 'INVALID_ARGS');
+    const downloaded = await downloadAvatarBuffer(url.trim());
+    if (!Buffer.isBuffer(downloaded))
+        return downloaded;
+    return uploadAvatarBuffer(aid, downloaded, opts);
 }

package/dist/utils/cross-platform.js

@@ -449,7 +449,10 @@ export function resolveCliEntry(packageRoot) {
         try {
             const require = createRequire(path.join(packageRoot, 'package.json'));
             const tsxUrl = pathToFileURL(require.resolve('tsx')).href;
-            return { args: ['--import', tsxUrl, sourceEntry], usingSource: true, entry: sourceEntry };
+            const imports = process.platform === 'win32'
+                ? ['--import', 'data:text/javascript,globalThis.process.geteuid=()=>-1', '--import', tsxUrl]
+                : ['--import', tsxUrl];
+            return { args: [...imports, sourceEntry], usingSource: true, entry: sourceEntry };
         }
         catch {
             // tsx missing (e.g. `npm prune --production`): fall through to dist.
@@ -488,11 +491,37 @@ export function encodePath(projectPath) {
 /**
  * Cross-platform process liveness check.
  */
+function readLinuxProcessState(pid) {
+    if (process.platform !== 'linux')
+        return null;
+    try {
+        const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+        // The comm field may contain ')', so use the final closing parenthesis.
+        const closeParen = stat.lastIndexOf(')');
+        if (closeParen < 0)
+            return null;
+        return stat.slice(closeParen + 2, closeParen + 3) || null;
+    }
+    catch {
+        // Keep the kill(0) fallback below for permission and procfs races.
+        return null;
+    }
+}
+/** Return the Linux proc state (for example Z, D, S, or R), when available. */
+export function getProcessState(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return null;
+    return readLinuxProcessState(pid);
+}
 export function isProcessRunning(pid) {
     if (!Number.isInteger(pid) || pid <= 0)
         return false;
     if (isWindows)
         return isWindowsProcessRunning(pid);
+    // A zombie has exited; only its unreaped process-table entry remains.  A
+    // kill(pid, 0) probe alone reports such an entry as alive on Linux.
+    if (readLinuxProcessState(pid) === 'Z')
+        return false;
     try {
         process.kill(pid, 0);
         return true;

package/dist/utils/error-utils.js

@@ -4,6 +4,14 @@ import { getPackageRoot, resolvePaths } from '../paths.js';
 import { logger } from './logger.js';
 import { isSandboxInitializationFailure } from '../core/permission/sandbox-runtime.js';
 export const CLAUDE_STARTUP_ARGUMENTS_TOO_LONG = 'claude_startup_arguments_too_long';
+/** A completed provider response exhausted its output budget, rather than a transport failure. */
+export function isOutputTokenLimitError(error) {
+    const record = error && typeof error === 'object' ? error : undefined;
+    const message = String(record?.message ?? error ?? '');
+    return record?.code === 'max_output_tokens'
+        || /^\s*max_output_tokens\s*$/i.test(message)
+        || /\breason["']?\s*[:=]\s*["']?max_output_tokens\b/i.test(message);
+}
 /** Identify a Claude process-start failure without treating ordinary tool errors as startup failures. */
 export function isClaudeStartupArgumentsTooLong(error) {
     const code = error && typeof error === 'object' && 'code' in error
@@ -36,6 +44,7 @@ export var ErrorType;
     ErrorType["AUTH_ERROR"] = "auth_error";
     ErrorType["FILE_CORRUPT"] = "file_corrupt";
     ErrorType["STREAM_ERROR"] = "stream_error";
+    ErrorType["MAX_OUTPUT_TOKENS"] = "max_output_tokens";
     ErrorType["CONTEXT_TOO_LONG"] = "context_too_long";
     ErrorType["MODEL_UNAVAILABLE"] = "model_unavailable";
     ErrorType["SESSION_UNAVAILABLE"] = "session_unavailable";
@@ -78,6 +87,7 @@ const NON_INFRA_SUBTYPES = new Set([
     'stop',
 ]);
 const NON_INFRA_TERMINAL_REASONS = new Set([
+    'max_output_tokens',
     'rapid_refill_breaker',
     'tool_deferred',
     'stop_hook_prevented',
@@ -279,6 +289,9 @@ function hasRetryableHttpStatus(text) {
 }
 export function classifyError(error) {
     const msg = (error?.message || '').toLowerCase();
+    // The broad dictionary rule for "stream" must not hide a provider budget limit.
+    if (isOutputTokenLimitError(error))
+        return ErrorType.MAX_OUTPUT_TOKENS;
     if (error?.code === 'TOPIC_BACKEND_UNAVAILABLE') {
         return ErrorType.SESSION_UNAVAILABLE;
     }
@@ -333,6 +346,9 @@ export function classifyError(error) {
  * 注意：401 认证错误不可重试（API Key 无效不会因重试恢复）
  */
 export function isRetryableError(error) {
+    // Replaying the same request does not increase its output budget.
+    if (isOutputTokenLimitError(error))
+        return false;
     const msg = error?.message || String(error);
     const lower = msg.toLowerCase();
     // 字典优先 — 命中则直接返回
@@ -350,6 +366,11 @@ export function isRetryableError(error) {
     return false;
 }
 export function getErrorMessage(error, terminalReason, includeEmoji = true) {
+    if (terminalReason === 'max_output_tokens' || isOutputTokenLimitError(error)) {
+        const prefix = includeEmoji ? '⚠️ ' : '';
+        return `${prefix}模型响应达到输出上限（max_output_tokens），本轮未完成。`
+            + '请降低推理强度或提高模型服务的输出预算，然后在原会话发送“继续，先核对已完成操作，只完成剩余工作”；无需重发原任务。';
+    }
     if (isClaudeStartupArgumentsTooLong(error)) {
         const prefix = includeEmoji ? '⚠️ ' : '';
         return `${prefix}当前 Claude 启动参数过长，任务未执行`;