@co0ontty/wand 4.82.0 → 4.83.1

package/dist/decision-tool.js

@@ -0,0 +1,346 @@
+/** Small shell lexer: quoted examples are one argument, not executable commands; heredoc bodies are data. */
+function commandWords(source) {
+    const commands = [];
+    let words = [];
+    let word = "";
+    let quote = "";
+    const pushWord = () => { if (word)
+        words.push(word); word = ""; };
+    const pushCommand = () => { pushWord(); if (words.length)
+        commands.push(words); words = []; };
+    for (let i = 0; i < source.length; i++) {
+        const c = source[i];
+        if (c === "\\" && quote !== "'" && i + 1 < source.length) {
+            if (source[i + 1] !== "\n")
+                word += source[i + 1];
+            i++;
+        }
+        else if (quote) {
+            if (c === quote)
+                quote = "";
+            else
+                word += c;
+        }
+        else if (c === "'" || c === '"') {
+            quote = c;
+        }
+        else if (c === "#" && !word) {
+            while (i < source.length && source[i] !== "\n")
+                i++;
+            pushCommand();
+        }
+        else if (c === "<" && source[i + 1] === "<") {
+            pushCommand();
+            break;
+        }
+        else if (c === ";" || c === "|" || c === "&" || c === "\n") {
+            pushCommand();
+        }
+        else if (/\s/.test(c)) {
+            pushWord();
+        }
+        else
+            word += c;
+    }
+    pushCommand();
+    return commands;
+}
+function isDecisionCommand(words, depth = 0) {
+    if (depth > 2 || !words.length)
+        return false;
+    const base = (value) => value.replace(/\\/g, "/").split("/").at(-1).toLowerCase();
+    // Prefix assignments and common harmless launch wrappers don't change the called program.
+    while (words.length && (/^[A-Za-z_][A-Za-z0-9_]*=/.test(words[0]) || ["env", "command"].includes(words[0])))
+        words = words.slice(1);
+    const executable = base(words[0] ?? "");
+    if (["sh", "bash", "zsh"].includes(executable)) {
+        const index = words.findIndex((word) => /^-[a-z]*c[a-z]*$/.test(word));
+        return index >= 0 && commandWords(words[index + 1] ?? "").some((command) => isDecisionCommand(command, depth + 1));
+    }
+    if (["curl", "curl.exe"].includes(executable)) {
+        return words.slice(1).some((word) => /^(?:https?:\/\/|\$\{?WAND_DECISION_URL\}?\/)/.test(word)
+            && /\/api\/decisions\/evaluate(?:[?#]|$)/.test(word));
+    }
+    const stdin = words.indexOf("--stdin");
+    if (stdin < 0)
+        return false;
+    if (["wand", "wand.cmd", "wand.exe"].includes(executable))
+        return words[1] === "decide";
+    if (!["node", "node.exe", "$wand_decision_node", "${wand_decision_node}"].includes(executable))
+        return false;
+    return words.slice(1, stdin).some((word, index) => {
+        const path = word.replace(/\\/g, "/");
+        if (/(?:^|\/)wand-decision\/scripts\/decide\.mjs$/.test(path))
+            return true;
+        const cli = /(?:^|\/)wand\/(?:dist\/cli\.js|src\/cli\.ts)$/.test(path)
+            || /^\$\{?WAND_DECISION_CLI\}?$/.test(path);
+        return cli && words[index + 2] === "decide";
+    });
+}
+export function isDecisionToolCall(block) {
+    if (block.semantic?.kind === "decision")
+        return true;
+    if (block.type && block.type !== "tool_use")
+        return false;
+    const operation = (block.name ?? "").toLowerCase().split(/__|[/.]/).at(-1) ?? "";
+    if (!["bash", "exec", "exec_command", "command_execution", "shell_command", "terminal", "run_command", "run_shell_command"].includes(operation))
+        return false;
+    const input = block.input ?? {};
+    const command = input.command ?? input.cmd;
+    if (Array.isArray(command) && command.every((word) => typeof word === "string"))
+        return isDecisionCommand(command);
+    if (typeof command !== "string" || command.length > 65536
+        || !/decide|\/api\/decisions\/evaluate/.test(command))
+        return false;
+    return commandWords(command).some((words) => isDecisionCommand(words));
+}
+// ── 缩略卡投影 ────────────────────────────────────────────────────────────────
+//
+// 决策卡收起时也要能看出「问了什么、答了什么」。展示数据统一由服务端从这里派生，
+// Web 与 Android 只渲染同一份字段，不各自解析原始 command / 结果 JSON。
+// 边界：只读、有界、可重复（同样的入参与结果必须得到同样的摘要），
+// 数据来源本来就随这次调用全量传输，摘要不扩大暴露面。
+const PREVIEW_MAX = 64;
+const OUTCOME_MAX = 160;
+const LABEL_MAX = 180;
+const ANSWER_ID_MAX = 24;
+const ANSWER_VALUE_MAX = 24;
+const SCAN_MAX = 32768;
+const MAX_CANDIDATES = 8;
+const MODE_HINTS = {
+    choice: "选择", score: "评分", noul: "是非判断", mixed: "混合判断",
+};
+const GENERIC_HINT = "选择 / 评分 / 是非判断";
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+/** 折叠空白并截断：摘要永远单行、有界。 */
+function collapse(text, max) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > max ? `${flat.slice(0, Math.max(1, max - 1))}…` : flat;
+}
+function modeOf(types) {
+    const unique = new Set(types);
+    if (!unique.size)
+        return undefined;
+    return unique.size > 1 ? "mixed" : [...unique][0];
+}
+/** 工具结果文本：字符串原样，结构化内容取 text 分片。 */
+function toolResultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.flatMap((part) => isRecord(part) && typeof part.text === "string" ? [part.text] : []).join("\n");
+}
+/** heredoc 正文（`<<'JSON'` … `JSON`）：Skill 的标准调用形态把请求体放在这里。 */
+function heredocBody(source) {
+    const match = /<<-?\s*(['"]?)([A-Za-z0-9_]+)\1[^\n]*\n/.exec(source);
+    if (!match)
+        return null;
+    const delimiter = match[2];
+    const lines = source.slice(match.index + match[0].length).split("\n");
+    const body = [];
+    for (const line of lines) {
+        if (line.trim() === delimiter || body.length > 2000)
+            break;
+        body.push(line);
+    }
+    const text = body.join("\n").trim();
+    return text || null;
+}
+/** 从一个 `{` 开始做引号感知的配对扫描，失败返回 null（宁可没有摘要也不猜）。 */
+function braceSpan(source, start) {
+    let depth = 0;
+    let quote = "";
+    for (let i = start; i < source.length && i - start <= SCAN_MAX; i++) {
+        const char = source[i];
+        if (quote) {
+            if (char === "\\") {
+                i++;
+                continue;
+            }
+            if (char === quote)
+                quote = "";
+            continue;
+        }
+        if (char === '"') {
+            quote = char;
+            continue;
+        }
+        if (char === "{")
+            depth++;
+        else if (char === "}" && --depth === 0)
+            return source.slice(start, i + 1);
+    }
+    return null;
+}
+/** 命令里的候选 JSON 文本：heredoc 正文优先，再扫内联对象。 */
+function jsonCandidates(source) {
+    const candidates = [];
+    const heredoc = heredocBody(source);
+    if (heredoc)
+        candidates.push(heredoc);
+    for (let i = 0; i < source.length && candidates.length < MAX_CANDIDATES; i++) {
+        if (source[i] !== "{")
+            continue;
+        const span = braceSpan(source, i);
+        if (!span)
+            break;
+        if (!candidates.includes(span))
+            candidates.push(span);
+        i += span.length - 1;
+    }
+    return candidates;
+}
+function decisionCommands(input) {
+    if (!input)
+        return [];
+    const command = input.command ?? input.cmd;
+    if (typeof command === "string")
+        return [command];
+    if (Array.isArray(command))
+        return command.filter((word) => typeof word === "string");
+    return [];
+}
+/** 请求侧要点：被判定内容摘要 + 题数 + 模式。请求体读不出时整块省略。 */
+function requestDigest(input) {
+    for (const source of decisionCommands(input)) {
+        for (const candidate of jsonCandidates(source)) {
+            let value;
+            try {
+                value = JSON.parse(candidate);
+            }
+            catch {
+                continue;
+            }
+            if (!isRecord(value) || !isRecord(value.questions))
+                continue;
+            const questions = Object.entries(value.questions);
+            if (!questions.length)
+                continue;
+            const types = [];
+            let recognized = 0;
+            for (const [, raw] of questions) {
+                if (!isRecord(raw))
+                    continue;
+                if (raw.type === "choice" || raw.type === "score" || raw.type === "noul") {
+                    types.push(raw.type);
+                    recognized++;
+                }
+            }
+            if (!recognized)
+                continue;
+            return {
+                mode: modeOf(types),
+                questions: questions.length,
+                ...statePreview(value.state),
+            };
+        }
+    }
+    return null;
+}
+function statePreview(state) {
+    if (typeof state === "string") {
+        const preview = collapse(state, PREVIEW_MAX);
+        return preview ? { preview } : {};
+    }
+    if (Array.isArray(state))
+        return state.length ? { preview: `${state.length} 项输入` } : {};
+    if (isRecord(state)) {
+        const fields = Object.keys(state).length;
+        return fields ? { preview: `${fields} 字段输入` } : {};
+    }
+    return {};
+}
+function percent(probability) {
+    return typeof probability === "number" && Number.isFinite(probability) && probability >= 0 && probability <= 1
+        ? ` ${Math.round(probability * 100)}%` : "";
+}
+function probabilityOf(probabilities, key) {
+    return isRecord(probabilities) ? probabilities[key] : undefined;
+}
+/** 单题结论：`id=选项 84%` / `id=档位 70%` / `id=P(true) 96%`，读不出该题就不编。 */
+function answerOutcome(id, answer) {
+    const name = collapse(id, ANSWER_ID_MAX);
+    if (!name)
+        return null;
+    if (answer.type === "choice" && typeof answer.choice === "string") {
+        const choice = collapse(answer.choice, ANSWER_VALUE_MAX);
+        return choice ? `${name}=${choice}${percent(probabilityOf(answer.probabilities, answer.choice))}` : null;
+    }
+    if (answer.type === "score" && typeof answer.score === "number" && Number.isFinite(answer.score)) {
+        // score 是期望档位（连续值），不是某一档的概率：显示 期望/满分 + 就近档位说明，
+        // 不拿单档概率冒充结论（本地模型的概率不是正确率）。
+        const levels = isRecord(answer.legend) ? Object.keys(answer.legend).length
+            : isRecord(answer.probabilities) ? Object.keys(answer.probabilities).length : 0;
+        const value = answer.score.toFixed(2);
+        const scale = levels > 1 ? `${value}/${levels - 1}` : value;
+        const legend = levels ? (isRecord(answer.legend) ? answer.legend[String(Math.round(answer.score))] : undefined) : undefined;
+        const hint = typeof legend === "string" && legend.trim() ? `（${collapse(legend, ANSWER_VALUE_MAX)}）` : "";
+        return `${name}=${scale}${hint}`;
+    }
+    if (answer.type === "noul" && typeof answer.noul === "number") {
+        return `${name}=P(true)${percent(answer.noul)}`;
+    }
+    return null;
+}
+/** 结果侧结论：只在真的解析出 answers 时给出，失败/非决策输出/截断内容一律省略。 */
+function resultDigest(content) {
+    const text = toolResultText(content).trim();
+    if (!text || text.length > 256 * 1024)
+        return null;
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(value) || !isRecord(value.answers))
+        return null;
+    const answers = Object.entries(value.answers);
+    if (!answers.length)
+        return null;
+    const types = [];
+    const items = [];
+    for (const [id, raw] of answers) {
+        if (!isRecord(raw))
+            continue;
+        if (raw.type === "choice" || raw.type === "score" || raw.type === "noul")
+            types.push(raw.type);
+        const outcome = answerOutcome(id, raw);
+        if (outcome)
+            items.push(outcome);
+    }
+    const mode = modeOf(types);
+    if (!items.length && !mode)
+        return null;
+    return {
+        mode,
+        questions: answers.length,
+        ...(items.length ? { outcome: collapse(items.join(" · "), OUTCOME_MAX) } : {}),
+    };
+}
+/**
+ * 卡头副标题：结论优先（窄屏先被省略的是被判定内容，不是答案），再题数、再要点的有界拼接；
+ * 两边都缺数据时退化为模式提示，客户端因此不需要自带一套决策文案。
+ * 状态词（运行中/完成/失败）不在这里，由客户端按自己的状态源渲染。
+ */
+export function decisionCardSummary(input, result) {
+    const request = requestDigest(input);
+    const resultFields = result && !result.is_error ? resultDigest(result.content) : null;
+    const mode = request?.mode ?? resultFields?.mode;
+    const questions = request?.questions ?? resultFields?.questions;
+    const parts = [resultFields?.outcome, questions ? `${questions} 题` : undefined, request?.preview]
+        .filter((part) => !!part);
+    const label = parts.length ? collapse(parts.join(" · "), LABEL_MAX)
+        : (mode ? MODE_HINTS[mode] : GENERIC_HINT);
+    return {
+        ...(mode ? { mode } : {}),
+        ...(questions ? { questions } : {}),
+        ...(request?.preview ? { preview: request.preview } : {}),
+        ...(resultFields?.outcome ? { outcome: resultFields.outcome } : {}),
+        label,
+    };
+}

package/dist/decision-types.d.ts

@@ -0,0 +1,36 @@
+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";
+export interface LocalDecisionConfig {
+    enabled: boolean;
+    pythonPath: string;
+    modelPath: string;
+}
+export interface DecisionQuestion {
+    type: "choice" | "score" | "noul";
+    instructions: string;
+    criteria?: Record<string, string> | string[];
+}
+export interface DecisionRequest {
+    state: string | unknown[] | Record<string, unknown>;
+    questions: Record<string, DecisionQuestion>;
+}
+export interface DecisionResult {
+    model: string;
+    answers: Record<string, Record<string, unknown>>;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        truncated?: boolean;
+    };
+    experimental: true;
+    runtime: "laya-mlx";
+}
+export declare class DecisionError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(code: string, message: string, status?: number);
+}
+export declare function parseDecisionRequest(value: unknown): DecisionRequest;
+export declare function parseDecisionResult(raw: unknown, request: DecisionRequest): DecisionResult;

package/dist/decision-types.js

@@ -0,0 +1,123 @@
+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";
+export class DecisionError extends Error {
+    code;
+    status;
+    constructor(code, message, status = 400) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = "DecisionError";
+    }
+}
+function record(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function text(value, max) {
+    return typeof value === "string" && !!value.trim() && value.length <= max;
+}
+function invalid() {
+    throw new DecisionError("INVALID_REQUEST", "需要有界 state 与 1–8 道 choice/score/noul 问题；每题指令最多500字符，选项2–8项。");
+}
+function jsonDepth(value, depth = 0) {
+    if (depth > 8)
+        invalid();
+    if (value && typeof value === "object") {
+        for (const child of Object.values(value))
+            jsonDepth(child, depth + 1);
+    }
+    else if (typeof value === "number" && !Number.isFinite(value))
+        invalid();
+}
+export function parseDecisionRequest(value) {
+    if (!record(value) || Object.keys(value).some((key) => key !== "state" && key !== "questions"))
+        invalid();
+    if (!(text(value.state, 16000) || Array.isArray(value.state) || record(value.state)))
+        invalid();
+    jsonDepth(value);
+    if (Buffer.byteLength(JSON.stringify(value)) > DECISION_MAX_BYTES) {
+        throw new DecisionError("REQUEST_TOO_LARGE", "决策请求超过32KiB。", 413);
+    }
+    if (!record(value.questions))
+        invalid();
+    const entries = Object.entries(value.questions);
+    if (!entries.length || entries.length > DECISION_MAX_QUESTIONS)
+        invalid();
+    const questions = Object.create(null);
+    for (const [id, raw] of entries) {
+        if (!/^[a-zA-Z0-9_-]{1,64}$/.test(id) || ["__proto__", "constructor", "prototype"].includes(id)
+            || !record(raw) || !text(raw.instructions, 500)
+            || Object.keys(raw).some((key) => !["type", "instructions", "criteria"].includes(key)))
+            invalid();
+        const { type, instructions, criteria } = raw;
+        if (type === "choice") {
+            const options = Array.isArray(criteria)
+                ? criteria.map((label) => [label, label])
+                : record(criteria) ? Object.entries(criteria) : [];
+            if (options.length < 2 || options.length > DECISION_MAX_OPTIONS
+                || options.some(([label, description]) => !text(label, 80) || !text(description, 300)
+                    || ["__proto__", "constructor", "prototype"].includes(label))
+                || new Set(options.map(([label]) => label)).size !== options.length)
+                invalid();
+            questions[id] = { type, instructions, criteria: Object.fromEntries(options) };
+        }
+        else if (type === "score") {
+            if (!Array.isArray(criteria) || criteria.length < 2 || criteria.length > DECISION_MAX_OPTIONS
+                || !criteria.every((level) => text(level, 300)))
+                invalid();
+            questions[id] = { type, instructions, criteria: [...criteria] };
+        }
+        else if (type === "noul") {
+            if (criteria !== undefined && (!record(criteria) || Object.keys(criteria).some((key) => !["true", "false"].includes(key))
+                || !Object.values(criteria).every((description) => text(description, 300))))
+                invalid();
+            questions[id] = { type, instructions, ...(criteria === undefined ? {} : { criteria: { ...criteria } }) };
+        }
+        else
+            invalid();
+    }
+    // Detach the accepted input from caller mutations while it waits in the queue.
+    return JSON.parse(JSON.stringify({ state: value.state, questions }));
+}
+export function parseDecisionResult(raw, request) {
+    const fail = () => { throw new DecisionError("INVALID_RESULT", "决策引擎返回了无效结果。", 502); };
+    if (!record(raw) || !record(raw.answers) || !record(raw.usage))
+        return fail();
+    const answers = raw.answers;
+    if (Object.keys(answers).length !== Object.keys(request.questions).length)
+        return fail();
+    const probability = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 && n <= 1;
+    for (const [id, question] of Object.entries(request.questions)) {
+        const answer = answers[id];
+        if (!record(answer) || answer.type !== question.type)
+            return fail();
+        if (question.type === "noul") {
+            if (!probability(answer.noul))
+                return fail();
+        }
+        else {
+            const labels = question.type === "choice" ? Object.keys(question.criteria) : question.criteria.map((_, i) => String(i));
+            if (!record(answer.probabilities) || Object.keys(answer.probabilities).length !== labels.length
+                || labels.some((label) => !probability(answer.probabilities[label]))
+                || Math.abs(Object.values(answer.probabilities).reduce((sum, n) => sum + n, 0) - 1) > 0.002)
+                return fail();
+            if (question.type === "choice" && (typeof answer.choice !== "string" || !labels.includes(answer.choice)))
+                return fail();
+            if (question.type === "score" && (typeof answer.score !== "number" || !Number.isFinite(answer.score)
+                || answer.score < 0 || answer.score > labels.length - 1))
+                return fail();
+        }
+        for (const field of ["confidence", "answer_confidence"]) {
+            if (answer[field] !== undefined && !probability(answer[field]))
+                return fail();
+        }
+    }
+    if (!Number.isSafeInteger(raw.usage.input_tokens) || raw.usage.input_tokens < 0
+        || raw.usage.input_tokens > DECISION_MAX_QUESTIONS * 1024 || raw.usage.output_tokens !== 0
+        || raw.usage.truncated !== false)
+        return fail();
+    return { model: DECISION_CHECKPOINT, answers: answers,
+        usage: raw.usage, experimental: true, runtime: "laya-mlx" };
+}

package/dist/decision-worker.py

@@ -0,0 +1,86 @@
+"""Wand's bounded, offline MLX worker. stdout is protocol only; no tools or DB access."""
+import json
+import os
+from pathlib import Path
+import sys
+
+MAX_LINE = 65536
+
+
+def emit(value):
+    print(json.dumps(value, ensure_ascii=False, allow_nan=False), flush=True)
+
+
+def main():
+    # The parent also supplies a minimal env; enforce offline behavior here too.
+    os.environ["HF_HUB_OFFLINE"] = "1"
+    os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    import mlx.core as mx
+    import laya_mlx as laya
+    from laya_mlx.common import collapsed_options, render_options
+
+    if not mx.metal.is_available():
+        raise RuntimeError("Metal unavailable")
+    model = Path(sys.argv[1])
+    if not model.is_absolute() or not model.is_dir():
+        raise ValueError("Local model required")
+    metadata = json.loads((model / "mlx_config.json").read_text())
+    if metadata.get("repository") != "aac6fef/laya-multilingual-mlx":
+        raise ValueError("Unexpected checkpoint identity")
+    mx.set_cache_limit(128 * 1024**2)
+    mx.set_memory_limit(2 * 1024**3)
+    agent = laya.load(str(model), device="gpu", dtype="float16", batch_size=1)
+    if agent.cfg.get("max_len") != 1024:
+        raise ValueError("A 1024-token multilingual checkpoint is required")
+    emit({"type": "ready", "protocol": 1})
+    while True:
+        line = sys.stdin.buffer.readline(MAX_LINE + 1)
+        if not line:
+            return
+        if len(line) > MAX_LINE:
+            raise ValueError("Protocol size limit")
+        request = json.loads(line)
+        request_id = request["id"]
+        try:
+            data = request["request"]
+            # The upstream prefix builder also truncates instructions/options separately.
+            # Reject before that happens: a lost negation must not become a confident answer.
+            prefix_fits = True
+            for definition in data["questions"].values():
+                question = agent._to_internal(definition)
+                instruction = str(question["ins"]).replace(agent.tok.mask_token, " ")
+                head_size = len(agent.tok(f"{question['t']} question: {instruction}")["input_ids"])
+                option_sizes = [1 + len(agent.tok(" " + option.replace(agent.tok.mask_token, " "))["input_ids"])
+                                for option in render_options(question)]
+                budget = agent.cfg.get("head_max_len", 192) - sum(option_sizes)
+                if any(size > 49 for size in option_sizes) or budget < 16 or head_size > max(8, budget):
+                    prefix_fits = False
+                    break
+            if not prefix_fits:
+                emit({"id": request_id, "error": "QUESTION_LIMIT"})
+                continue
+            items, _ = agent.prepare(data["state"], data["questions"])
+            if any(item["state_stats"]["truncated"] for item in items):
+                emit({"id": request_id, "error": "CONTEXT_LIMIT"})
+                continue
+            if collapsed_options(list(data["questions"]), items):
+                emit({"id": request_id, "error": "OPTIONS_COLLAPSED"})
+                continue
+            result = agent.predict(data["state"], data["questions"])
+            mx.synchronize()
+            emit({"id": request_id, "result": result})
+        except (ValueError, TypeError, KeyError):
+            emit({"id": request_id, "error": "INVALID_REQUEST"})
+        except Exception:
+            # Inference failure may leave GPU state unhealthy: fail closed and restart on a later request.
+            emit({"id": request_id, "error": "INFERENCE_FAILED"})
+            return
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        sys.stderr.write("Wand decision worker failed. Check the configured local runtime.\n")
+        sys.exit(1)

package/dist/default-employee.d.ts

@@ -1,11 +1,14 @@
 import { type SiliconEmployee } from "./ai-team-types.js";
 import type { WandStorage } from "./storage.js";
 import type { WandTaskAgent } from "./task-types.js";
-import type { SessionProvider } from "./types.js";
+import type { SessionProvider, SessionSnapshot } from "./types.js";
 import type { UserMemoryProfile } from "./user-memory-types.js";
 export declare const DEFAULT_EMPLOYEE_DUTY = "\u9ED8\u8BA4\u4EFB\u52A1\u4F19\u4F34\uFF1A\u7406\u89E3\u4F60\u7684\u9700\u6C42\uFF0C\u6309\u8BC1\u636E\u63A8\u8FDB\u5DE5\u4F5C\uFF0C\u5E76\u9010\u6B65\u9002\u5E94\u4F60\u7684\u6C9F\u901A\u4E0E\u4EA4\u4ED8\u4E60\u60EF\u3002";
 export declare const DEFAULT_EMPLOYEE_PROMPT: string;
 /** Keep the immutable identity/base rules outside the model's output. */
 export declare function defaultEmployeeDefinition(agents: WandTaskAgent[], now: string, existing?: SiliconEmployee | null, profile?: UserMemoryProfile | null, time?: number): SiliconEmployee;
+export type SessionEmployeeIdentity = Pick<SessionSnapshot, "employeeId" | "employeeName" | "employeeAvatar">;
+/** Older PTY sessions stored the injected role only as a prompt. Never infer from a CLI or a name mention. */
+export declare function legacyPtyRoleIdentity(session: Pick<SessionSnapshot, "sessionKind" | "provider" | "systemPrompt" | "employeeId">): SessionEmployeeIdentity;
 /** Snapshot a role at creation. Selecting a CLI never selects a different execution candidate. */
 export declare function defaultRoleForCli(storage: WandStorage, provider?: SessionProvider): SiliconEmployee;

package/dist/default-employee.js

@@ -1,4 +1,4 @@
-import { DEFAULT_EMPLOYEE_ID, DEFAULT_EMPLOYEE_KEY, DEFAULT_EMPLOYEE_NAME, } from "./ai-team-types.js";
+import { DEFAULT_EMPLOYEE_ID, DEFAULT_EMPLOYEE_KEY, DEFAULT_EMPLOYEE_NAME, DEFAULT_EMPLOYEE_TAG, } from "./ai-team-types.js";
 import { systemEmployeeSeedAgents } from "./system-employee.js";
 export const DEFAULT_EMPLOYEE_DUTY = "默认任务伙伴：理解你的需求，按证据推进工作，并逐步适应你的沟通与交付习惯。";
 export const DEFAULT_EMPLOYEE_PROMPT = [
@@ -18,6 +18,7 @@ export function defaultEmployeeDefinition(agents, now, existing, profile, time =
     return {
         id: existing?.id ?? DEFAULT_EMPLOYEE_ID,
         systemKey: DEFAULT_EMPLOYEE_KEY,
+        tags: [DEFAULT_EMPLOYEE_TAG],
         name: DEFAULT_EMPLOYEE_NAME,
         duty: DEFAULT_EMPLOYEE_DUTY,
         prompt: DEFAULT_EMPLOYEE_PROMPT + memory,
@@ -27,6 +28,15 @@ export function defaultEmployeeDefinition(agents, now, existing, profile, time =
         updatedAt: now,
     };
 }
+/** Older PTY sessions stored the injected role only as a prompt. Never infer from a CLI or a name mention. */
+export function legacyPtyRoleIdentity(session) {
+    const prompt = session.systemPrompt?.trim();
+    if (session.employeeId || (session.sessionKind ?? "pty") !== "pty" || !session.provider
+        || !(prompt === DEFAULT_EMPLOYEE_PROMPT
+            || prompt?.startsWith(DEFAULT_EMPLOYEE_PROMPT + "\n\n近期使用偏好（仅作参考；本轮要求冲突时忽略）：\n")))
+        return {};
+    return { employeeId: DEFAULT_EMPLOYEE_ID, employeeName: DEFAULT_EMPLOYEE_NAME, employeeAvatar: "" };
+}
 /** Snapshot a role at creation. Selecting a CLI never selects a different execution candidate. */
 export function defaultRoleForCli(storage, provider) {
     return storage.getDefaultSiliconEmployee() ?? storage.ensureDefaultSiliconEmployee(provider);

package/dist/env-utils.js

@@ -47,6 +47,9 @@ export function buildChildEnv(inheritEnv, extras = {}) {
                 base[key] = v;
         }
     }
+    // Do not let nested Wand/PTY or one-shot automation inherit another run's decision capability.
+    for (const key of ["WAND_DECISION_URL", "WAND_DECISION_TOKEN", "WAND_DECISION_CA", "WAND_DECISION_NODE", "WAND_DECISION_CLI"])
+        delete base[key];
     for (const [k, v] of Object.entries(extras)) {
         if (typeof v === "string")
             base[k] = v;

package/dist/git-quick-commit.js

@@ -622,8 +622,14 @@ function runCliText(command, args, prompt, opts) {
         // The writable stream emits EPIPE independently of ChildProcess.error;
         // without a listener that becomes an uncaught exception after callers
         // have already finished their turn or closed storage.
+        //
+        // A closed stdin is only a delivery failure when we actually had prompt
+        // bytes to send. Arg-driven providers (e.g. `pi`) are called with an empty
+        // prompt, so the child may close stdin before we end the stream; treating
+        // that as failure made the same run succeed or fail at random.
+        const expectsStdin = prompt.length > 0;
         child.stdin?.on("error", (error) => {
-            if (settled)
+            if (settled || !expectsStdin)
                 return;
             settled = true;
             clearTimeout(timeout);

package/dist/message-truncator.d.ts

@@ -1,4 +1,4 @@
-/** Keep tool payloads out of all chat snapshots and fetch them only when opened. */
+/** Keep full tool payloads out of compact snapshots; retain bounded card previews. */
 import type { CardExpandDefaults, ContentBlock, ConversationTurn } from "./types.js";
 export interface WindowedMessages {
     /** 已截断 + 窗口化后的 turn 列表（最近 windowSize 条）。 */