@co0ontty/wand 4.89.5 → 4.90.0

package/dist/decision-expert-service.js

@@ -1,8 +1,8 @@
-import { DECISION_EXPERT_ID, DECISION_EXPERT_KEY, WAND_LOCAL_DECISION_MODEL } from "./decision-expert-identity.js";
+import { DECISION_EXPERT_ID, DECISION_EXPERT_KEY, DECISION_EXPERT_NAME, WAND_LOCAL_DECISION_MODEL } from "./decision-expert-identity.js";
 import { decisionHardware } from "./decision-hardware.js";
-import { DecisionError, parseDecisionRequest, parseDecisionResult } from "./decision-types.js";
+import { DECISION_CANDIDATE_TIMEOUT_MS, DecisionError, parseDecisionRequest, parseDecisionResult } from "./decision-types.js";
 import { isOpenRouterFreeSelector } from "./openrouter-free-models.js";
-import { abortableEmployeeText, EmployeeCandidateRejected, employeeTextCandidates, prepareEmployeeTextCandidate } from "./employee-text.js";
+import { abortableEmployeeText, employeeTextCandidates, prepareEmployeeTextCandidate } from "./employee-text.js";
 /** Bounded decisions use the employee's ordered adapters; LAYA stays a local evaluator. */
 export class DecisionExpertService {
     deps;
@@ -23,108 +23,114 @@ export class DecisionExpertService {
         });
         return { enabled: !!employee, supported: true, configured, state: local.state, queued: this.active,
             completed: local.completed, failed: local.failed, experimental: true,
-            hardware, employeeId: employee?.id ?? DECISION_EXPERT_ID, employeeName: employee?.name ?? "决策专家",
+            hardware, employeeId: employee?.id ?? DECISION_EXPERT_ID, employeeName: employee?.name ?? DECISION_EXPERT_NAME,
             notice: !hardware.suitable ? hardware.message : !local.enabled || !local.configured
-                ? "本地决策未就绪，可初始化 LAYA 或配置「决策专家」的工具与模型调用链。" : null };
+                ? `本地决策未就绪，可初始化 LAYA 或配置「${DECISION_EXPERT_NAME}」的工具与模型调用链。` : null };
     }
     async evaluate(value, caller, signal) {
         const request = parseDecisionRequest(value), employee = this.deps.employee();
         if (!employee || employee.systemKey !== DECISION_EXPERT_KEY)
-            throw new DecisionError("UNAVAILABLE", "请先配置「决策专家」员工调用链。", 503);
+            throw new DecisionError("UNAVAILABLE", `请先配置「${DECISION_EXPERT_NAME}」员工调用链。`, 503);
         if (signal?.aborted)
             throw new DecisionError("CANCELLED", "决策已取消。", 499);
         if (this.active >= 8)
-            throw new DecisionError("BUSY", "决策专家队列已满，请稍后重试。", 429);
+            throw new DecisionError("BUSY", `${DECISION_EXPERT_NAME}的决策队列已满，请稍后重试。`, 429);
         this.active += 1;
-        const deadline = new AbortController();
-        const timeout = new DecisionError("TIMEOUT", "决策专家请求超时，请稍后重试或调整该员工调用链。", 504);
-        const timer = setTimeout(() => deadline.abort(timeout), this.deps.timeoutMs ?? 45_000);
-        signal = signal ? AbortSignal.any([signal, deadline.signal]) : deadline.signal;
+        const cancelled = () => {
+            if (signal?.aborted)
+                throw new DecisionError("CANCELLED", `${employee.name}的决策请求已取消。`, 499);
+        };
+        const candidates = employeeTextCandidates(employee.agents, this.deps.config);
+        const failures = [];
+        let executed = false, sawTimeout = false, otherExecutionFailure = false;
         const prompt = {
             system: `${employee.prompt}\n只输出JSON对象 {"answers":{...}}。对每题保留type；choice给choice和所有criteria的probabilities(总和1)，score给score和以0开始索引的probabilities(总和1)，noul给0到1的noul。不得执行操作或增加候选。概率是实验性辅助而非授权。`,
             prompt: JSON.stringify(request),
         };
         try {
-            const hardware = (this.deps.hardware ?? decisionHardware)();
-            for (const { agent, index: candidate } of employeeTextCandidates(employee.agents, this.deps.config)) {
-                signal.throwIfAborted();
-                if (agent.model === WAND_LOCAL_DECISION_MODEL) {
-                    if (agent.provider !== "pi" || agent.engine !== "sdk" || agent.kind !== "structured")
-                        continue;
-                    const local = this.deps.local.status();
-                    if (!hardware.suitable || !local.enabled || !local.configured || !local.supported)
-                        continue;
-                    try {
-                        const result = await abortableEmployeeText(this.deps.local.evaluate(request, caller, signal), signal);
+            for (const { agent, index: candidate } of candidates) {
+                cancelled();
+                const deadline = new AbortController();
+                const members = candidates.filter(entry => entry.index === candidate).length;
+                const timer = setTimeout(() => deadline.abort(new DecisionError("TIMEOUT", "候选决策超时。", 504)), Math.max(1, Math.floor((this.deps.timeoutMs ?? DECISION_CANDIDATE_TIMEOUT_MS) / members)));
+                const attempt = signal ? AbortSignal.any([signal, deadline.signal]) : deadline.signal;
+                let stage = "availability";
+                try {
+                    if (agent.model === WAND_LOCAL_DECISION_MODEL) {
+                        const hardware = (this.deps.hardware ?? decisionHardware)(), local = this.deps.local.status();
+                        if (agent.provider !== "pi" || agent.engine !== "sdk" || agent.kind !== "structured"
+                            || !hardware.suitable || !local.enabled || !local.configured || !local.supported) {
+                            throw new DecisionError("UNAVAILABLE", "LAYA 不可用。", 503);
+                        }
+                        stage = "execution";
+                        executed = true;
+                        const localResult = await abortableEmployeeText(this.deps.local.evaluate(request, caller, attempt), attempt);
+                        stage = "result";
+                        const result = parseDecisionResult(localResult, request, { model: localResult.model, runtime: "laya-mlx" });
+                        cancelled();
+                        attempt.throwIfAborted();
                         return { ...result, executor: { employeeId: employee.id, candidate, source: "local" } };
                     }
-                    catch (error) {
-                        signal.throwIfAborted();
-                        if (error instanceof DecisionError && ["CANCELLED", "INVALID_REQUEST", "RATE_LIMIT", "BUSY"].includes(error.code))
-                            throw error;
-                        // Existing LAYA fallback is read-only inference, never tool/task replay.
-                        continue;
-                    }
-                }
-                let run;
-                if (this.deps.generate) {
-                    run = () => this.deps.generate(agent, request, employee, signal);
-                }
-                else {
-                    const availability = new AbortController();
-                    const checkTimer = setTimeout(() => availability.abort(new Error("候选可用性检查超时。")), 8000);
-                    const check = AbortSignal.any([signal, availability.signal]);
-                    let generate;
-                    let usage;
-                    try {
-                        generate = await abortableEmployeeText((this.deps.prepare ?? ((next, text, checkedSignal) => prepareEmployeeTextCandidate({
-                            config: this.deps.config, free: this.deps.free, onUsage: value => { usage = value; },
-                        }, next, text, checkedSignal)))(agent, prompt, check), check);
-                    }
-                    catch {
-                        signal.throwIfAborted();
-                        continue;
+                    let run;
+                    if (this.deps.generate) {
+                        run = () => this.deps.generate(agent, request, employee, attempt);
                     }
-                    finally {
-                        clearTimeout(checkTimer);
+                    else {
+                        const availability = new AbortController();
+                        const checkTimer = setTimeout(() => availability.abort(new Error("候选可用性检查超时。")), 8000);
+                        const check = AbortSignal.any([attempt, availability.signal]);
+                        let generate;
+                        let usage;
+                        try {
+                            generate = await abortableEmployeeText((this.deps.prepare ?? ((next, text, checkedSignal) => prepareEmployeeTextCandidate({
+                                config: this.deps.config, free: this.deps.free, onUsage: value => { usage = value; },
+                            }, next, text, checkedSignal)))(agent, prompt, check), check);
+                        }
+                        finally {
+                            clearTimeout(checkTimer);
+                        }
+                        run = async () => {
+                            const raw = await abortableEmployeeText(generate(), attempt);
+                            stage = "result";
+                            if (raw.length > 32768)
+                                throw new Error("决策结果超过32KiB。");
+                            const body = JSON.parse(raw.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, ""));
+                            return { answers: body?.answers, inputTokens: usage?.inputTokens ?? 0, outputTokens: usage?.outputTokens ?? 0,
+                                model: usage?.model ?? agent.model, available: !!usage };
+                        };
                     }
-                    run = async () => {
-                        const raw = await abortableEmployeeText(generate(), signal);
-                        if (raw.length > 32768)
-                            throw new Error("决策结果超过32KiB。");
-                        const body = JSON.parse(raw.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, ""));
-                        return { answers: body?.answers, inputTokens: usage?.inputTokens ?? 0, outputTokens: usage?.outputTokens ?? 0,
-                            model: usage?.model ?? agent.model, available: !!usage };
-                    };
-                }
-                try {
-                    const generated = await abortableEmployeeText(run(), signal);
-                    signal.throwIfAborted();
+                    stage = "execution";
+                    executed = true;
+                    const generated = await abortableEmployeeText(run(), attempt);
+                    stage = "result";
                     const result = parseDecisionResult({ answers: generated.answers, usage: { input_tokens: generated.inputTokens, output_tokens: generated.outputTokens, truncated: false } }, request, { model: generated.model, runtime: "decision-expert" });
+                    cancelled();
+                    attempt.throwIfAborted();
                     if (generated.available === false)
                         result.usage.available = false;
                     return { ...result, executor: { employeeId: employee.id, candidate,
                             source: isOpenRouterFreeSelector(agent.model) ? "free-group" : agent.engine === "sdk" ? "sdk" : "cli" } };
                 }
                 catch (error) {
-                    signal.throwIfAborted();
-                    if (error instanceof EmployeeCandidateRejected && error.failure.retryable)
-                        continue;
-                    // Accepted/unknown delivery and invalid results never silently repeat a request.
-                    throw new DecisionError("EXECUTION_FAILED", "决策专家候选调用失败或结果无效，未自动重放；请检查该员工调用链。", 503);
+                    cancelled();
+                    const timedOut = deadline.signal.aborted || error instanceof DecisionError && error.code === "TIMEOUT";
+                    sawTimeout ||= timedOut;
+                    otherExecutionFailure ||= !timedOut && stage !== "availability";
+                    failures.push(`候选${candidate + 1}：${timedOut ? "超时" : stage === "availability" ? "不可用" : stage === "result" ? "结果无效" : "调用失败"}`);
+                    // Explicit decision-only fallback: no tools or task replay, and no unconfigured models.
+                    // Even unknown delivery / malformed answers advance; only caller cancellation stops the chain.
+                }
+                finally {
+                    clearTimeout(timer);
+                    deadline.abort();
                 }
             }
-            throw new DecisionError("CONFIGURATION_REQUIRED", "决策专家没有当前可用的候选；请检查已配置工具、模型或初始化 LAYA。", 503);
-        }
-        catch (error) {
-            if (deadline.signal.aborted)
-                throw timeout;
-            if (signal.aborted)
-                throw new DecisionError("CANCELLED", "决策专家请求已取消。", 499);
-            throw error;
+            cancelled();
+            const timedOut = sawTimeout && !otherExecutionFailure;
+            const code = timedOut ? "TIMEOUT" : executed ? "EXECUTION_FAILED" : "CONFIGURATION_REQUIRED";
+            throw new DecisionError(code, `${employee.name}已尝试全部配置的决策候选，均未成功${failures.length ? `（${failures.join("；").slice(0, 2048)}）` : ""}；请检查该员工调用链。`, timedOut ? 504 : 503);
         }
         finally {
-            clearTimeout(timer);
             this.active -= 1;
         }
     }

package/dist/decision-hardware.js

@@ -1,16 +1,17 @@
 import os from "node:os";
+import { DECISION_EXPERT_NAME } from "./decision-expert-identity.js";
 export function assessDecisionHardware(value) {
     const gib = 1024 ** 3, memoryGiB = Math.round(value.memoryBytes / gib * 10) / 10, availableGiB = Math.round(value.availableBytes / gib * 10) / 10;
     const base = { memoryGiB, availableGiB, cpuCount: value.cpuCount, minimumMemoryGiB: 8 };
-    const insufficient = "当前机器性能或平台条件不足，建议配置「决策专家」员工的调用链，通过备用模型使用。";
+    const insufficient = `当前机器性能或平台条件不足，建议配置「${DECISION_EXPERT_NAME}」员工的调用链，通过备用模型使用。`;
     if (value.platform !== "darwin" || value.arch !== "arm64")
         return { ...base, suitable: false, code: "platform", message: `LAYA 本地决策需要 Apple Silicon macOS / Metal。${insufficient}` };
     if (value.metal === false)
         return { ...base, suitable: false, code: "metal", message: `当前 Metal 不可用。${insufficient}` };
     if (value.memoryBytes < 7.5 * gib)
-        return { ...base, suitable: false, code: "memory", message: `当前机器性能不够（内存 ${memoryGiB} GiB，建议至少 8 GiB）。请配置「决策专家」员工调用链使用备用模型。` };
+        return { ...base, suitable: false, code: "memory", message: `当前机器性能不够（内存 ${memoryGiB} GiB，建议至少 8 GiB）。请配置「${DECISION_EXPERT_NAME}」员工调用链使用备用模型。` };
     if (value.cpuCount < 4)
-        return { ...base, suitable: false, code: "cpu", message: `当前机器性能不够（可用 CPU ${value.cpuCount} 核，建议至少 4 核）。请配置「决策专家」员工调用链。` };
+        return { ...base, suitable: false, code: "cpu", message: `当前机器性能不够（可用 CPU ${value.cpuCount} 核，建议至少 4 核）。请配置「${DECISION_EXPERT_NAME}」员工调用链。` };
     // Darwin's free memory excludes reclaimable cache. Don't falsely reject an otherwise capable Mac based on that number alone.
     return { ...base, suitable: true, code: "ready", message: "本机基本配置满足 LAYA 本地决策要求；实际运行时与 Metal 能力仍需初始化验证。" };
 }

package/dist/decision-types.d.ts

@@ -2,6 +2,10 @@ export declare const DECISION_MAX_BYTES: number;
 export declare const DECISION_MAX_QUESTIONS = 8;
 export declare const DECISION_MAX_OPTIONS = 8;
 export declare const DECISION_CHECKPOINT = "aac6fef/laya-multilingual-mlx";
+/** Each saved employee slot gets its own budget; group leaves share that slot. */
+export declare const DECISION_CANDIDATE_TIMEOUT_MS = 45000;
+/** At most four saved slots, plus transport/cleanup overhead. */
+export declare const DECISION_CHAIN_WAIT_MS: number;
 export interface LocalDecisionConfig {
     enabled: boolean;
     pythonPath: string;

package/dist/decision-types.js

@@ -3,6 +3,10 @@ export const DECISION_MAX_BYTES = 32 * 1024;
 export const DECISION_MAX_QUESTIONS = 8;
 export const DECISION_MAX_OPTIONS = 8;
 export const DECISION_CHECKPOINT = "aac6fef/laya-multilingual-mlx";
+/** Each saved employee slot gets its own budget; group leaves share that slot. */
+export const DECISION_CANDIDATE_TIMEOUT_MS = 45_000;
+/** At most four saved slots, plus transport/cleanup overhead. */
+export const DECISION_CHAIN_WAIT_MS = DECISION_CANDIDATE_TIMEOUT_MS * 4 + 5_000;
 export function parseLocalDecisionConfig(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error("本地决策配置无效。");

package/dist/deployment-lock.d.ts

@@ -0,0 +1,13 @@
+export interface DeploymentLock {
+    lockPath: string;
+    token: string;
+    ownerPid: number;
+    owned: boolean;
+}
+/** Existing npm updaters and local deployment use the same atomic directory protocol. */
+export declare function acquireDeploymentLock(value: string, options?: {
+    ownerPid?: number;
+    inherited?: readonly DeploymentLock[];
+}): DeploymentLock;
+export declare function releaseDeploymentLock(lock: DeploymentLock): void;
+export declare function acquireDeploymentLocks(paths: readonly string[], ownerPid?: number): DeploymentLock[];

package/dist/deployment-lock.js

@@ -0,0 +1,189 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function canonicalLockPath(value) {
+    const absolute = path.resolve(value);
+    mkdirSync(path.dirname(absolute), { recursive: true });
+    return path.join(realpathSync(path.dirname(absolute)), path.basename(absolute));
+}
+function ownerOf(lockPath) {
+    try {
+        return JSON.parse(readFileSync(path.join(lockPath, "owner.json"), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+/** Existing npm updaters and local deployment use the same atomic directory protocol. */
+export function acquireDeploymentLock(value, options = {}) {
+    const lockPath = canonicalLockPath(value);
+    const ownerPid = options.ownerPid ?? process.pid;
+    if (!Number.isSafeInteger(ownerPid) || ownerPid <= 0)
+        throw new Error("无效的部署锁进程。");
+    const owner = ownerOf(lockPath);
+    const inherited = options.inherited?.find(lock => lock.lockPath === lockPath
+        && lock.token === owner?.token && lock.ownerPid === owner?.pid && pidAlive(lock.ownerPid));
+    if (inherited)
+        return { ...inherited, owned: false };
+    const token = randomUUID();
+    try {
+        mkdirSync(lockPath, { mode: 0o700 });
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+        throw new Error(`另一个 wand 更新正在进行中（锁: ${lockPath}${typeof owner?.pid === "number" ? `, PID ${owner.pid}` : ""}）。若确认没有更新进程，请手动处理该锁目录。`);
+    }
+    try {
+        writeFileSync(path.join(lockPath, "owner.json"), `${JSON.stringify({ pid: ownerPid, token, createdAt: Date.now() })}\n`, { mode: 0o600 });
+    }
+    catch (error) {
+        // No other cooperative writer can have acquired the directory we just created.
+        rmSync(lockPath, { recursive: true, force: true });
+        throw error;
+    }
+    return { lockPath, token, ownerPid, owned: true };
+}
+export function releaseDeploymentLock(lock) {
+    if (!lock.owned)
+        return;
+    const owner = ownerOf(lock.lockPath);
+    if (owner?.token === lock.token && owner.pid === lock.ownerPid) {
+        rmSync(lock.lockPath, { recursive: true, force: true });
+    }
+}
+export function acquireDeploymentLocks(paths, ownerPid = process.pid) {
+    const acquired = [];
+    try {
+        for (const lockPath of [...new Set(paths)])
+            acquired.push(acquireDeploymentLock(lockPath, { ownerPid }));
+        return acquired;
+    }
+    catch (error) {
+        for (const lock of acquired.reverse())
+            releaseDeploymentLock(lock);
+        throw error;
+    }
+}
+function receipts(raw) {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed))
+        throw new Error("无效的部署锁回执。");
+    return parsed.map((item) => {
+        if (!item || typeof item !== "object")
+            throw new Error("无效的部署锁回执。");
+        const lock = item;
+        if (typeof lock.lockPath !== "string" || !path.isAbsolute(lock.lockPath)
+            || typeof lock.token !== "string" || !Number.isSafeInteger(lock.ownerPid) || lock.ownerPid <= 0
+            || typeof lock.owned !== "boolean")
+            throw new Error("无效的部署锁回执。");
+        return lock;
+    });
+}
+async function runProjectCommand(command) {
+    if (!command.length)
+        throw new Error("部署锁缺少执行命令。");
+    const inherited = process.env.WAND_DEPLOYMENT_LOCKS ? receipts(process.env.WAND_DEPLOYMENT_LOCKS) : [];
+    const lock = acquireDeploymentLock(path.join(process.cwd(), ".wand-build-lock"), { inherited });
+    try {
+        const env = { ...process.env, WAND_DEPLOYMENT_LOCKS: JSON.stringify([...inherited, lock]) };
+        const child = spawn(command[0], command.slice(1), { stdio: "inherit", env, detached: process.platform !== "win32" });
+        let interrupted = null;
+        const interrupt = (signal) => {
+            interrupted = signal;
+            try {
+                if (process.platform !== "win32" && child.pid)
+                    process.kill(-child.pid, signal);
+                else
+                    child.kill(signal);
+            }
+            catch (error) {
+                if (error.code !== "ESRCH")
+                    throw error;
+            }
+        };
+        const onInt = () => interrupt("SIGINT");
+        const onTerm = () => interrupt("SIGTERM");
+        process.on("SIGINT", onInt);
+        process.on("SIGTERM", onTerm);
+        try {
+            const status = await new Promise((resolve, reject) => {
+                child.once("error", reject);
+                child.once("close", code => resolve(code));
+            });
+            // npm can exit before a grandchild finishes handling the signal. Keep the lease
+            // until every writer in this owned build/check process group has actually gone.
+            if (process.platform !== "win32" && child.pid) {
+                while (true) {
+                    try {
+                        process.kill(-child.pid, 0);
+                    }
+                    catch (error) {
+                        if (error.code === "ESRCH")
+                            break;
+                        throw error;
+                    }
+                    await new Promise(resolve => setTimeout(resolve, 50));
+                }
+            }
+            process.exitCode = interrupted === "SIGINT" ? 130 : interrupted === "SIGTERM" ? 143 : status ?? 1;
+        }
+        finally {
+            process.off("SIGINT", onInt);
+            process.off("SIGTERM", onTerm);
+        }
+    }
+    finally {
+        releaseDeploymentLock(lock);
+    }
+}
+async function main() {
+    const [mode, ...args] = process.argv.slice(2);
+    if (mode === "--run-project") {
+        if (args.shift() !== "--")
+            throw new Error("部署锁命令需用 -- 分隔。");
+        await runProjectCommand(args);
+        return;
+    }
+    if (args[0] !== "--owner-pid" || !/^\d+$/.test(args[1] ?? ""))
+        throw new Error("部署锁需要 owner-pid。");
+    const pid = Number(args[1]);
+    args.splice(0, 2);
+    if (mode === "--acquire") {
+        const paths = [];
+        while (args.length) {
+            if (args.shift() !== "--lock" || !args.length)
+                throw new Error("无效的部署锁路径参数。");
+            paths.push(args.shift());
+        }
+        if (!paths.length)
+            throw new Error("部署锁路径不能为空。");
+        process.stdout.write(JSON.stringify(acquireDeploymentLocks(paths, pid)));
+    }
+    else if (mode === "--release") {
+        if (args.length)
+            throw new Error("释放部署锁不接受多余参数。");
+        const locks = receipts(readFileSync(0, "utf8"));
+        if (locks.some(lock => lock.ownerPid !== pid))
+            throw new Error("部署锁归属不匹配。");
+        for (const lock of locks.reverse())
+            releaseDeploymentLock(lock);
+    }
+    else {
+        throw new Error("未知部署锁操作。");
+    }
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    main().catch(error => { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 1; });
+}

package/dist/employee-text.js

@@ -75,7 +75,7 @@ export async function prepareEmployeeTextCandidate(deps, agent, request, signal)
     if (agent.engine !== "sdk") {
         if (!providerCliInstalled(agent.provider) || isOpenRouterFreeSelector(agent.model))
             throw new Error("CLI候选不可用。");
-        const { callCliAiText, assertGeminiTextCapability } = await import("./git-quick-commit.js");
+        const { callCliAiText, assertGeminiTextCapability } = await import("./ai-text-runner.js");
         if (agent.provider === "gemini")
             assertGeminiTextCapability();
         // One adapter call, never re-enter the candidate chain.

package/dist/fixed-employee-avatar.d.ts

@@ -18,6 +18,13 @@ export declare function employeeAvatarValue(identity: {
     systemKey?: string | null;
     avatar?: string | null;
 }): string;
+/** Uploaded photos are data URLs up to 60KB. Short tokens are the only avatar bytes lists should repeat. */
+export declare function isUploadedAvatar(value: string | null | undefined): boolean;
+/**
+ * List cards, nested session summaries and routine events keep plush/cat tokens.
+ * Uploaded bytes stay on the employee record, session detail and the first init packet.
+ */
+export declare function compactTransportAvatar(value: string | null | undefined): string | undefined;
 /** The avatar exception does not change any other built-in employee's edit policy. */
 export declare function isFixedAvatarEmployee(identity: {
     id?: string | null;

package/dist/fixed-employee-avatar.js

@@ -11,6 +11,19 @@ export function fixedEmployeeAvatar(identity) {
 export function employeeAvatarValue(identity) {
     return fixedEmployeeAvatar(identity) ?? identity.avatar ?? "";
 }
+/** Uploaded photos are data URLs up to 60KB. Short tokens are the only avatar bytes lists should repeat. */
+export function isUploadedAvatar(value) {
+    return typeof value === "string" && value.startsWith("data:");
+}
+/**
+ * List cards, nested session summaries and routine events keep plush/cat tokens.
+ * Uploaded bytes stay on the employee record, session detail and the first init packet.
+ */
+export function compactTransportAvatar(value) {
+    if (!value || isUploadedAvatar(value))
+        return undefined;
+    return value;
+}
 /** The avatar exception does not change any other built-in employee's edit policy. */
 export function isFixedAvatarEmployee(identity) {
     return fixedEmployeeAvatar(identity) !== null;

package/dist/git-quick-commit.d.ts

@@ -1,7 +1,9 @@
-import { type EmployeeTextDeps } from "./employee-text.js";
-import type { AiTextRequest } from "./types.js";
 import { GitStatusResult, PushResult, QuickCommitResult, SessionProvider, SessionSnapshot, TagHeadResult } from "./types.js";
-export type QuickCommitErrorCode = "CWD_MISSING" | "NO_CWD" | "NOT_A_GIT_REPO" | "NO_COMMIT" | "NOTHING_TO_COMMIT" | "NOTHING_TO_PUSH" | "EMPTY_MESSAGE" | "EMPTY_TAG" | "EMPTY_AI_MESSAGE" | "AI_FALLBACK_FAILED" | "INVALID_AI_TAG" | "TAG_EXISTS" | "GIT_ADD_FAILED" | "GIT_DIFF_FAILED" | "GIT_COMMIT_FAILED" | "GIT_TAG_FAILED" | "CLAUDE_CLI_MISSING" | "CLAUDE_CLI_FAILED" | "CLAUDE_TIMEOUT";
+/** provider 缺省值：无法识别时回落到 Claude。 */
+import { type QuickCommitAiOptions } from "./ai-text-runner.js";
+export { assertGeminiTextCapability, callCliAiText, callConfiguredAiText, withOpsPersona } from "./ai-text-runner.js";
+export type { QuickCommitAiOptions } from "./ai-text-runner.js";
+export { QuickCommitError, type QuickCommitErrorCode } from "./command-error.js";
 /** Non-blocking status implementation used by HTTP routes. */
 export declare function getGitStatusAsync(cwd: string): Promise<GitStatusResult>;
 interface QuickCommitOptions extends CommitInputOptions, QuickCommitAiOptions {
@@ -19,28 +21,6 @@ interface QuickCommitOptions extends CommitInputOptions, QuickCommitAiOptions {
      */
     submodule?: boolean;
 }
-export interface QuickCommitAiOptions {
-    modelGroups?: import("./model-groups.js").ModelGroup[];
-    provider?: SessionProvider;
-    model?: string | null;
-    thinkingEffort?: SessionSnapshot["thinkingEffort"];
-    inheritEnv?: boolean;
-    /** 内置「系统运维」员工的角色设定：作为系统提示前缀注入。 */
-    opsPersona?: string;
-    /** 员工候选链（按顺序）；未设置时只用 provider/model 这一次调用。 */
-    cliCandidates?: import("./types.js").AiCliCandidate[];
-    /** SDK 使用当前实例配置与现有免费分组服务，不创建其他执行渠道。 */
-    employeeText?: EmployeeTextDeps;
-    /** 系统应用必须经员工渠道；没有可用候选时直接失败，不退回默认 provider。 */
-    employeeChannelOnly?: boolean;
-    /** 整条候选链的时间上限；默认 CLI_CHAIN_BUDGET_MS。第一条消息里的调用要短得多。 */
-    budgetMs?: number;
-    signal?: AbortSignal;
-}
-export declare class QuickCommitError extends Error {
-    readonly code: QuickCommitErrorCode;
-    constructor(message: string, code: QuickCommitErrorCode);
-}
 /**
  * 生成 commit message / tag 的输入源。
  *   - iterationDigest：本轮迭代的提示词标题清单（默认输入，省 token、不读代码）；
@@ -51,20 +31,6 @@ export interface CommitInputOptions {
     iterationDigest?: string;
     includeDiff?: boolean;
 }
-type CliAiTextOptions = QuickCommitAiOptions & {
-    deadline?: number;
-};
-export declare function assertGeminiTextCapability(): void;
-export declare function callCliAiText(request: AiTextRequest, cwd: string, language: string, opts: CliAiTextOptions): Promise<string>;
-/** 角色设定走系统提示前缀；任务自己的输出格式与约束必须排在后面。 */
-export declare function withOpsPersona(request: AiTextRequest, persona?: string): AiTextRequest;
-/**
- * Run a lightweight AI request through the system employee's configured chain.
- * provider 与引擎由候选决定；SDK 与 CLI 均保留各自适配和身份。
- * parseOutput 在候选链内解析/校验结果；失败后继续下一条，而非提前宣布成功。
- */
-export declare function callConfiguredAiText(request: AiTextRequest, cwd: string, language: string, opts: QuickCommitAiOptions): Promise<string>;
-export declare function callConfiguredAiText<T>(request: AiTextRequest, cwd: string, language: string, opts: QuickCommitAiOptions, parseOutput: (raw: string) => T): Promise<T>;
 export interface GenerateCommitMessageResult {
     message: string;
     /** AI-suggested next tag derived from the staged diff and the latest existing tag. */
@@ -97,4 +63,3 @@ interface PushOptions {
 export declare function runPush(opts: PushOptions): Promise<PushResult>;
 export declare function runQuickCommitWithFallback(opts: QuickCommitOptions): Promise<QuickCommitResult>;
 export declare function runQuickCommit(opts: QuickCommitOptions): Promise<QuickCommitResult>;
-export {};