@co0ontty/wand 4.94.0 → 4.95.0

package/dist/conversation-service.d.ts

@@ -1,6 +1,7 @@
 import { type AiTeamRun } from "./ai-team-types.js";
 import { type AiTeamRunner } from "./ai-team-runner.js";
 import { type ConversationDetail, type ConversationInstance, type ConversationReceipt, type ConversationSummary, type ConversationTarget, type ConversationSessionUpdate } from "./conversation-types.js";
+import { type ConversationExecutionPreference } from "./conversation-execution-preference.js";
 import type { WandStorage } from "./storage.js";
 import type { StructuredSessionManager } from "./structured-session-manager.js";
 import type { ConversationTurn, ProcessEvent, SessionSnapshot, WandConfig } from "./types.js";
@@ -88,7 +89,7 @@ export declare class ConversationService {
     /** Explicit resource action may prepare a channel; it never sends or starts a model. */
     prepare(id: string, requestId: string, explicitCwd?: string): Promise<ConversationReceipt>;
     private communicationChannel;
-    send(id: string, requestId: string, input: string, target: ConversationTarget, explicitCwd?: string, echo?: boolean, executionTarget?: ConversationExecutionTarget): Promise<ConversationReceipt>;
+    send(id: string, requestId: string, input: string, target: ConversationTarget, explicitCwd?: string, echo?: boolean, executionTarget?: ConversationExecutionTarget, executionPreference?: ConversationExecutionPreference): Promise<ConversationReceipt>;
     /** One IM message is one fresh model context. No task, team, relay or previous DM history. */
     private startMessageSession;
     private requireTarget;

package/dist/conversation-service.js

@@ -14,6 +14,7 @@ import { isGlobalWorkspace, normalizeProjectCwd, resolveWorkspaceIdForNewSession
 import { CONVERSATION_SESSION_PREFIX, conversationSessionPreview } from "./conversation-session-preview.js";
 import { conversationTaskLiveText } from "./conversation-task-preview.js";
 import { selectEmployeeCandidate } from "./silicon-employee-dispatch.js";
+import { parseConversationExecutionPreference, withConversationExecutionPreference } from "./conversation-execution-preference.js";
 import { userAuthor, userDisplayName } from "./user-profile.js";
 import { cleanupWorktreeSync } from "./git-worktree.js";
 import { provisionalTaskTitleFromDescription } from "./task-title.js";
@@ -621,13 +622,17 @@ export class ConversationService {
         this.storage.saveConversation(instance);
         return session;
     }
-    send(id, requestId, input, target, explicitCwd, echo = true, executionTarget) {
+    send(id, requestId, input, target, explicitCwd, echo = true, executionTarget, executionPreference) {
+        const preference = parseConversationExecutionPreference(executionPreference);
         return this.request(requestId, "send", { input, target, explicitCwd, echo,
+            ...(preference ? { executionPreference: preference } : {}),
             ...(executionTarget?.workspaceId ? { workspaceId: executionTarget.workspaceId } : {}),
             ...(executionTarget?.title !== undefined ? { title: executionTarget.title } : {}),
             ...(executionTarget?.scheduled ? { scheduled: true } : {}) }, id, async (receipt, commit) => {
             const text = shortText(input, "消息", 256_000, true);
             const instance = this.requireInstance(id);
+            if (preference && (instance.kind !== "dm" || target))
+                throw new Error("临时执行配置仅用于私聊的新工作，不修改已有任务。");
             let workspaceId;
             if (executionTarget) {
                 if (instance.kind !== "dm" || target)
@@ -664,7 +669,7 @@ export class ConversationService {
                 return;
             }
             if (instance.kind === "dm") {
-                this.startMessageSession(instance, requestId, text, explicitCwd, receipt, commit, executionTarget ? { ...executionTarget, workspaceId } : undefined);
+                this.startMessageSession(instance, requestId, text, explicitCwd, receipt, commit, executionTarget ? { ...executionTarget, workspaceId } : undefined, preference);
                 return;
             }
             if (instance.kind === "group" && instance.team) {
@@ -708,9 +713,10 @@ export class ConversationService {
         });
     }
     /** One IM message is one fresh model context. No task, team, relay or previous DM history. */
-    startMessageSession(instance, requestId, input, explicitCwd, receipt, commit, executionTarget) {
+    startMessageSession(instance, requestId, input, explicitCwd, receipt, commit, executionTarget, preference) {
         requireTeamEmployee(this.storage, instance.peerEmployeeId ?? "");
-        const employee = this.storage.getSiliconEmployee(instance.peerEmployeeId);
+        const savedEmployee = this.storage.getSiliconEmployee(instance.peerEmployeeId);
+        const employee = preference ? withConversationExecutionPreference(savedEmployee, preference) : savedEmployee;
         const selected = selectEmployeeCandidate(employee), agent = selected.agent;
         const cwd = this.cwd(explicitCwd);
         const model = agent.model === "default" ? fallbackProviderModel(this.deps.config, agent.provider) : agent.model;

package/dist/core-turn-tracker.d.ts

@@ -3,7 +3,11 @@
  */
 export declare class CoreTurnTracker {
     private static activeTurns;
-    static startTurn(sessionId: string): symbol;
+    private static systemCallDrains;
+    /** Admission for one-shot SDK calls which do not enter the ordinary session input queue. */
+    static beginSystemCallDrain(): () => void;
+    static assertSystemCallAdmission(): void;
+    static startTurn(sessionId: string, systemCall?: boolean): symbol;
     static endTurn(token: symbol): void;
     static hasActiveTurns(): boolean;
     static getActiveTurnCount(): number;

package/dist/core-turn-tracker.js

@@ -5,7 +5,23 @@ export class CoreTurnTracker {
     // Each execution owns its token: a late cancelled turn cannot untrack its
     // replacement in the same session.
     static activeTurns = new Map();
-    static startTurn(sessionId) {
+    static systemCallDrains = 0;
+    /** Admission for one-shot SDK calls which do not enter the ordinary session input queue. */
+    static beginSystemCallDrain() {
+        this.systemCallDrains++;
+        let released = false;
+        return () => { if (!released) {
+            released = true;
+            this.systemCallDrains--;
+        } };
+    }
+    static assertSystemCallAdmission() {
+        if (this.systemCallDrains > 0)
+            throw Object.assign(new Error("服务正在排空 Core，暂不接受新的 SDK 系统调用。"), { code: "SYSTEM_AI_DRAINING" });
+    }
+    static startTurn(sessionId, systemCall = false) {
+        if (systemCall)
+            this.assertSystemCallAdmission();
         const token = Symbol(sessionId);
         this.activeTurns.set(token, sessionId);
         return token;

package/dist/decision-expert-service.d.ts

@@ -5,7 +5,9 @@ import type { SiliconEmployee } from "./ai-team-types.js";
 import { type OpenRouterFreeModelsService } from "./openrouter-free-models.js";
 import type { AiTextRequest, WandConfig } from "./types.js";
 import type { WandTaskAgent } from "./task-types.js";
+import { type AiCallTraceFactory } from "./system-ai-call.js";
 interface DecisionExpertDeps {
+    trace?(employee: SiliconEmployee): AiCallTraceFactory;
     employee(): SiliconEmployee | null;
     local: Pick<DecisionService, "status" | "evaluate">;
     free: Pick<OpenRouterFreeModelsService, "status" | "resolveForCall">;

package/dist/decision-expert-service.js

@@ -3,6 +3,7 @@ import { decisionHardware } from "./decision-hardware.js";
 import { DECISION_CANDIDATE_TIMEOUT_MS, DecisionError, parseDecisionRequest, parseDecisionResult } from "./decision-types.js";
 import { isOpenRouterFreeSelector } from "./openrouter-free-models.js";
 import { abortableEmployeeText, employeeTextCandidates, prepareEmployeeTextCandidate } from "./employee-text.js";
+import { AiCallTraceError } from "./system-ai-call.js";
 /** Bounded decisions use the employee's ordered adapters; LAYA stays a local evaluator. */
 export class DecisionExpertService {
     deps;
@@ -47,7 +48,9 @@ export class DecisionExpertService {
             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),
         };
+        let trace;
         try {
+            trace = this.deps.trace?.(employee).start("decision", prompt, this.deps.config.defaultCwd);
             for (const { agent, index: candidate } of candidates) {
                 cancelled();
                 const deadline = new AbortController();
@@ -62,6 +65,7 @@ export class DecisionExpertService {
                             || !hardware.suitable || !local.enabled || !local.configured || !local.supported) {
                             throw new DecisionError("UNAVAILABLE", "LAYA 不可用。", 503);
                         }
+                        trace?.localStarted(agent.model);
                         stage = "execution";
                         executed = true;
                         const localResult = await abortableEmployeeText(this.deps.local.evaluate(request, caller, attempt), attempt);
@@ -69,8 +73,11 @@ export class DecisionExpertService {
                         const result = parseDecisionResult(localResult, request, { model: localResult.model, runtime: "laya-mlx" });
                         cancelled();
                         attempt.throwIfAborted();
+                        trace?.candidateSucceeded(JSON.stringify(localResult), result);
+                        trace?.complete();
                         return { ...result, executor: { employeeId: employee.id, candidate, source: "local" } };
                     }
+                    trace?.candidateStarted(agent);
                     let run;
                     if (this.deps.generate) {
                         run = () => this.deps.generate(agent, request, employee, attempt);
@@ -83,7 +90,7 @@ export class DecisionExpertService {
                         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; },
+                                config: this.deps.config, free: this.deps.free, callSessionId: trace?.sessionId, onUsage: value => { usage = value; trace?.usageReported(value); },
                             }, next, text, checkedSignal)))(agent, prompt, check), check);
                         }
                         finally {
@@ -108,10 +115,15 @@ export class DecisionExpertService {
                     attempt.throwIfAborted();
                     if (generated.available === false)
                         result.usage.available = false;
+                    trace?.candidateSucceeded(JSON.stringify(generated.answers), result);
+                    trace?.complete();
                     return { ...result, executor: { employeeId: employee.id, candidate,
                             source: isOpenRouterFreeSelector(agent.model) ? "free-group" : agent.engine === "sdk" ? "sdk" : "cli" } };
                 }
                 catch (error) {
+                    if (error instanceof AiCallTraceError)
+                        throw error;
+                    trace?.candidateFailed(agent, error, stage);
                     cancelled();
                     const timedOut = deadline.signal.aborted || error instanceof DecisionError && error.code === "TIMEOUT";
                     sawTimeout ||= timedOut;
@@ -130,6 +142,10 @@ export class DecisionExpertService {
             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);
         }
+        catch (error) {
+            trace?.fail(error, signal?.aborted === true);
+            throw error;
+        }
         finally {
             this.active -= 1;
         }

package/dist/decision-skill.d.ts

@@ -1,5 +1,4 @@
 import { type SessionProvider } from "./provider-catalog.js";
-/** One managed source, three discovery locations; never edits a provider's settings or permissions. */
 export declare function installDecisionSkill(configDir: string, providers?: readonly SessionProvider[], home?: string): Promise<{
     installed: string[];
     providers: readonly SessionProvider[];

package/dist/decision-skill.js

@@ -1,70 +1,11 @@
-import { createHash } from "node:crypto";
-import { readFile, mkdir, lstat, readlink, writeFile, symlink, realpath } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import path from "node:path";
 import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { installManagedSkill } from "./managed-skill.js";
 import { SESSION_PROVIDERS } from "./provider-catalog.js";
-const FILES = ["SKILL.md", "scripts/decide.mjs"];
-const sha = (data) => createHash("sha256").update(data).digest("hex");
-/** One managed source, three discovery locations; never edits a provider's settings or permissions. */
 export async function installDecisionSkill(configDir, providers = SESSION_PROVIDERS, home = homedir()) {
-    if (!providers.length || providers.some((provider) => !SESSION_PROVIDERS.includes(provider)))
-        throw new Error("未知CLI技能目标。");
-    const canonical = path.join(configDir, "skills", "wand-decision");
     const source = fileURLToPath(new URL("../skills/wand-decision/", import.meta.url));
-    const targets = new Set();
-    for (const provider of providers) {
-        const directory = provider === "claude" ? ".claude" : provider === "qoder" ? ".qoder" : ".agents";
-        targets.add(path.join(home, directory, "skills", "wand-decision"));
-    }
-    // Preflight every target before touching anything; existing user content is never replaced.
-    for (const target of targets) {
-        try {
-            const info = await lstat(target);
-            if (!info.isSymbolicLink() || path.resolve(path.dirname(target), await readlink(target)) !== path.resolve(canonical)) {
-                throw new Error(`已有同名技能，保留原内容，请先手动处理：${target}`);
-            }
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-    }
-    let previous = {};
-    try {
-        previous = JSON.parse(await readFile(path.join(canonical, ".wand-managed.json"), "utf8"));
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-    const contents = await Promise.all(FILES.map(async (file) => ({ file, content: await readFile(path.join(source, file), "utf8") })));
-    for (const { file, content } of contents) {
-        try {
-            const old = await readFile(path.join(canonical, file), "utf8");
-            if (old !== content && sha(old) !== previous[file])
-                throw new Error(`技能已有用户修改，拒绝覆盖：${file}`);
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-    }
-    await mkdir(path.join(canonical, "scripts"), { recursive: true });
-    for (const { file, content } of contents)
-        await writeFile(path.join(canonical, file), content, { mode: 0o644 });
-    await writeFile(path.join(canonical, ".wand-managed.json"), JSON.stringify(Object.fromEntries(contents.map(({ file, content }) => [file, sha(content)]))), { mode: 0o600 });
-    for (const target of targets) {
-        await mkdir(path.dirname(target), { recursive: true });
-        try {
-            await symlink(canonical, target, "dir");
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-        }
-        if (await realpath(target) !== await realpath(canonical))
-            throw new Error("技能链接目标校验失败。");
-    }
-    return { installed: [...targets], providers };
+    const files = Object.fromEntries(await Promise.all(["SKILL.md", "scripts/decide.mjs"].map(async (file) => [file, await readFile(path.join(source, file), "utf8")])));
+    return installManagedSkill(configDir, "wand-decision", files, providers, home);
 }

package/dist/deployment-lock.js

@@ -43,7 +43,10 @@ export function acquireDeploymentLock(value, options = {}) {
     catch (error) {
         if (error.code !== "EEXIST")
             throw error;
-        throw new Error(`另一个 wand 更新正在进行中（锁: ${lockPath}${typeof owner?.pid === "number" ? `, PID ${owner.pid}` : ""}）。若确认没有更新进程，请手动处理该锁目录。`);
+        const ownerState = Number.isSafeInteger(owner?.pid) && owner.pid > 0
+            ? pidAlive(owner.pid) ? "进程仍存活" : "进程已退出，可能存在遗留写者或未完成事务"
+            : "归属未知";
+        throw new Error(`另一个 wand 更新正在进行中或遗留安装锁尚未核实（锁: ${lockPath}${typeof owner?.pid === "number" ? `, PID ${owner.pid}` : ""}；${ownerState}）。旧安装未修改；未自动删除锁，请先核查安装子进程、备份与事务状态。`);
     }
     try {
         writeFileSync(path.join(lockPath, "owner.json"), `${JSON.stringify({ pid: ownerPid, token, createdAt: Date.now() })}\n`, { mode: 0o600 });

package/dist/employee-im-config.d.ts

@@ -0,0 +1,17 @@
+import { type EmployeeImConfig, type EmployeeImConfigInput } from "./employee-im-types.js";
+/** Server-only write-only credentials, never included in employee/session projections. */
+export interface EmployeeImCredentials {
+    botToken?: string;
+    webhook?: string;
+    secret?: string;
+}
+export interface EmployeeImSettings {
+    config: EmployeeImConfig;
+    credentials: EmployeeImCredentials;
+}
+export declare class EmployeeImConfigError extends Error {
+}
+export declare function dingTalkWebhook(value: string): URL;
+/** Older draft configs had per-channel events. Read them as one union without rewriting storage on GET. */
+export declare function normalizeStoredEmployeeImConfig(value: unknown): EmployeeImConfig;
+export declare function parseEmployeeImConfig(input: EmployeeImConfigInput | unknown, previous: EmployeeImSettings): EmployeeImSettings;

package/dist/employee-im-config.js

@@ -0,0 +1,85 @@
+import { EMPLOYEE_IM_EVENTS } from "./employee-im-types.js";
+export class EmployeeImConfigError extends Error {
+}
+const knownEvents = new Set(EMPLOYEE_IM_EVENTS.map(event => event.value));
+function object(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new EmployeeImConfigError("IM 配置必须是对象。");
+    return value;
+}
+function credential(value, previous, label, max) {
+    if (value === undefined || value === "")
+        return previous;
+    if (value === null)
+        return undefined;
+    if (typeof value !== "string" || value.length > max || /[\x00-\x20\x7f]/.test(value))
+        throw new EmployeeImConfigError(`${label}格式无效。`);
+    return value;
+}
+export function dingTalkWebhook(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new EmployeeImConfigError("请填写有效的钉钉机器人 Webhook。");
+    }
+    const token = url.searchParams.get("access_token");
+    if (url.protocol !== "https:" || url.hostname !== "oapi.dingtalk.com" || url.port || url.username || url.password
+        || url.pathname !== "/robot/send" || url.hash || !token || !/^[A-Za-z0-9_-]{8,256}$/.test(token)
+        || [...url.searchParams.keys()].some(key => key !== "access_token") || url.searchParams.getAll("access_token").length !== 1) {
+        throw new EmployeeImConfigError("仅支持 https://oapi.dingtalk.com/robot/send?access_token=… 官方机器人地址。");
+    }
+    return url;
+}
+/** Older draft configs had per-channel events. Read them as one union without rewriting storage on GET. */
+export function normalizeStoredEmployeeImConfig(value) {
+    const raw = object(value), telegram = object(raw.telegram), dingtalk = object(raw.dingtalk);
+    const source = Array.isArray(raw.events) ? raw.events
+        : [...(Array.isArray(telegram.events) ? telegram.events : []), ...(Array.isArray(dingtalk.events) ? dingtalk.events : [])];
+    return {
+        events: [...new Set(source.filter((event) => typeof event === "string" && knownEvents.has(event)))],
+        telegram: { enabled: telegram.enabled === true, chatId: typeof telegram.chatId === "string" ? telegram.chatId : "", botTokenConfigured: telegram.botTokenConfigured === true },
+        dingtalk: { enabled: dingtalk.enabled === true, webhookConfigured: dingtalk.webhookConfigured === true, secretConfigured: dingtalk.secretConfigured === true },
+    };
+}
+export function parseEmployeeImConfig(input, previous) {
+    const body = object(input);
+    const events = body.events === undefined ? previous.config.events : body.events;
+    if (!Array.isArray(events) || events.length > EMPLOYEE_IM_EVENTS.length
+        || events.some(event => typeof event !== "string" || !knownEvents.has(event)))
+        throw new EmployeeImConfigError("通知节点无效。");
+    const config = { events: [...new Set(events)] };
+    const credentials = { ...previous.credentials };
+    for (const provider of ["telegram", "dingtalk"]) {
+        const raw = object(body[provider]);
+        if (typeof raw.enabled !== "boolean")
+            throw new EmployeeImConfigError("请选择是否启用 IM 通知。");
+        config[provider] = { enabled: raw.enabled };
+        if (provider === "telegram") {
+            if (raw.chatId !== undefined && typeof raw.chatId !== "string")
+                throw new EmployeeImConfigError("Telegram Chat ID 格式无效。");
+            const chatId = raw.chatId?.trim() ?? previous.config.telegram.chatId ?? "";
+            if (chatId && !/^(?:-?\d{1,24}|@[A-Za-z0-9_]{5,32})$/.test(chatId))
+                throw new EmployeeImConfigError("Telegram Chat ID 格式无效。");
+            config.telegram.chatId = chatId;
+            credentials.botToken = credential(raw.botToken, credentials.botToken, "Telegram Bot Token", 256);
+            if (credentials.botToken && !/^\d{5,20}:[A-Za-z0-9_-]{20,200}$/.test(credentials.botToken))
+                throw new EmployeeImConfigError("Telegram Bot Token 格式无效。");
+            if (raw.enabled && (!credentials.botToken || !chatId))
+                throw new EmployeeImConfigError("启用 Telegram 前请填写 Bot Token 和 Chat ID。");
+        }
+        else {
+            credentials.webhook = credential(raw.webhook, credentials.webhook, "钉钉 Webhook", 1024);
+            credentials.secret = credential(raw.secret, credentials.secret, "钉钉签名密钥", 512);
+            if (credentials.webhook)
+                dingTalkWebhook(credentials.webhook);
+            if (raw.enabled && !credentials.webhook)
+                throw new EmployeeImConfigError("启用钉钉前请填写机器人 Webhook。");
+        }
+    }
+    config.telegram.botTokenConfigured = !!credentials.botToken;
+    config.dingtalk.webhookConfigured = !!credentials.webhook;
+    config.dingtalk.secretConfigured = !!credentials.secret;
+    return { config, credentials };
+}

package/dist/employee-im-lifecycle.d.ts

@@ -0,0 +1,35 @@
+import type { AiTeamRun, AiTeamStep } from "./ai-team-types.js";
+import type { EmployeeImEvent } from "./employee-im-types.js";
+import type { ProcessEvent, SessionSnapshot } from "./types.js";
+interface Notifier {
+    notify(employeeId: string, event: EmployeeImEvent, context: {
+        sessionId?: string;
+        title?: string;
+    }): void;
+}
+interface Options {
+    im: Notifier;
+    getSession(id: string): SessionSnapshot | null;
+    getRunSteps?(runId: string): AiTeamStep[];
+}
+/** Read-only projection of execution facts. Never parses assistant prose or synthesizes success from idle. */
+export declare class EmployeeImLifecycle {
+    private readonly options;
+    private readonly sessions;
+    private readonly runs;
+    private readonly pending;
+    private disposed;
+    constructor(options: Options);
+    /** Existing/recovered state is a baseline, not a new notification subscription replay. */
+    seed(sessions: SessionSnapshot[], runs?: AiTeamRun[]): void;
+    ingest(event: ProcessEvent): void;
+    private project;
+    /** Called at the runner's durable run/step change boundary, including async decisions after session end. */
+    ingestRun(run: AiTeamRun): void;
+    dispose(): void;
+    private readRun;
+    private read;
+    private remember;
+    private send;
+}
+export {};

package/dist/employee-im-lifecycle.js

@@ -0,0 +1,168 @@
+import { enrichStructuredMessages } from "./structured-client-protocol.js";
+/** Read-only projection of execution facts. Never parses assistant prose or synthesizes success from idle. */
+export class EmployeeImLifecycle {
+    options;
+    sessions = new Map();
+    runs = new Map();
+    pending = new Map();
+    disposed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    /** Existing/recovered state is a baseline, not a new notification subscription replay. */
+    seed(sessions, runs = []) {
+        for (const session of sessions)
+            if (session.employeeId)
+                this.sessions.set(session.id, { ...this.read(session), semanticPrimed: false });
+        for (const run of runs)
+            this.runs.set(run.id, this.readRun(run));
+    }
+    ingest(event) {
+        if (this.disposed || event.sessionId === "__system__" || event.type === "resync" || event.type === "notification" || event.type === "usage")
+            return;
+        // Text chunks are high-frequency; coalesce their semantic projection. Terminal/status facts are immediate.
+        if (event.type === "output") {
+            const data = event.data && typeof event.data === "object" ? event.data : {};
+            if (Array.isArray(data.queuedMessages) && data.queuedMessages.length !== (this.sessions.get(event.sessionId)?.queue ?? 0))
+                this.project(event.sessionId);
+            if (!this.pending.has(event.sessionId) && this.pending.size < 1000) {
+                const timer = setTimeout(() => { this.pending.delete(event.sessionId); this.project(event.sessionId); }, 100);
+                timer.unref?.();
+                this.pending.set(event.sessionId, timer);
+            }
+            return;
+        }
+        const timer = this.pending.get(event.sessionId);
+        if (timer) {
+            clearTimeout(timer);
+            this.pending.delete(event.sessionId);
+        }
+        const data = event.data && typeof event.data === "object" ? event.data : {};
+        this.project(event.sessionId, typeof data.completionRevision === "number" ? data.completionRevision : undefined, data.turnOutcome === "stopped");
+    }
+    project(id, revision, explicitlyStopped = false) {
+        if (this.disposed)
+            return;
+        const snapshot = this.options.getSession(id);
+        if (!snapshot?.employeeId)
+            return;
+        const next = this.read(snapshot);
+        const previous = this.sessions.get(id);
+        next.completion = Math.max(next.completion, revision ?? 0, previous?.completion ?? 0);
+        next.stopNotified = next.active ? false : previous?.stopNotified ?? false;
+        this.remember(this.sessions, id, next);
+        if (!previous && snapshot.autoRecovered)
+            return;
+        // A changed employee binding is a fresh baseline; never attribute another employee's old result.
+        if (previous && previous.employeeId !== snapshot.employeeId)
+            return;
+        const send = (event) => this.send(snapshot.employeeId, event, { sessionId: id, title: snapshot.title || snapshot.currentTaskTitle || "员工任务" });
+        if (next.active && (!previous?.active || (next.turn !== previous.turn && previous.turn !== "-1:")))
+            send("task_started");
+        if (next.permission && next.permission !== previous?.permission)
+            send("waiting_permission");
+        if (previous?.semanticPrimed !== false && [...next.questions].some(key => !previous?.questions.has(key)))
+            send("waiting_input");
+        if (next.queue > (previous?.queue ?? 0))
+            send("message_queued");
+        if (previous && next.candidate !== previous.candidate)
+            send("candidate_switched");
+        if (previous && next.completion > previous.completion)
+            send("task_completed");
+        if (next.outcome && next.outcome !== previous?.outcome) {
+            send(snapshot.status === "stopped" ? "task_stopped" : "task_failed");
+            if (snapshot.status === "stopped")
+                next.stopNotified = true;
+        }
+        if (explicitlyStopped && !next.stopNotified) {
+            send("task_stopped");
+            next.stopNotified = true;
+        }
+        if (previous?.semanticPrimed !== false && [...next.steps].some(([key, status]) => status === "completed"
+            && (next.turn !== previous?.turn || previous?.steps.get(key) !== "completed")))
+            send("step_completed");
+    }
+    /** Called at the runner's durable run/step change boundary, including async decisions after session end. */
+    ingestRun(run) {
+        if (this.disposed)
+            return;
+        const next = this.readRun(run);
+        const previous = this.runs.get(run.id);
+        this.remember(this.runs, run.id, next);
+        const leader = run.team.members.find(member => member.isLeader)?.employeeId;
+        const context = { sessionId: run.chatSessionId ?? undefined, title: run.team.name };
+        if (leader && previous?.status !== run.status) {
+            const event = { running: "team_started", done: "team_completed", failed: "team_failed", stopped: "team_stopped",
+                waiting_user: "waiting_input", awaiting_approval: "waiting_permission" }[run.status];
+            this.send(leader, event, context);
+        }
+        for (const step of this.options.getRunSteps?.(run.id) ?? []) {
+            if (step.status !== "done" || previous?.steps.get(step.id) === "done")
+                continue;
+            const employeeId = run.team.members.find(member => member.id === step.memberId)?.employeeId;
+            if (employeeId)
+                this.send(employeeId, "step_completed", { sessionId: step.sessionId ?? undefined, title: step.title });
+        }
+    }
+    dispose() {
+        this.disposed = true;
+        for (const timer of this.pending.values())
+            clearTimeout(timer);
+        this.pending.clear();
+        this.sessions.clear();
+        this.runs.clear();
+    }
+    readRun(run) {
+        return { status: run.status, steps: new Map((this.options.getRunSteps?.(run.id) ?? []).map(step => [step.id, step.status])) };
+    }
+    read(session) {
+        const active = session.status === "running" && (session.sessionKind === "structured" ? session.structuredState?.inFlight === true : session.ptyBusy === true);
+        // Only the current user turn participates; bound work on very large histories.
+        const messages = session.messages ?? [];
+        let start = messages.length - 1;
+        while (start >= 0 && !(messages[start].role === "user" && messages[start].content.some(block => block.type === "text")))
+            start -= 1;
+        const segment = messages.slice(Math.max(start, messages.length - 200, 0));
+        const results = new Map(segment.flatMap(turn => turn.content.flatMap(block => block.type === "tool_result" ? [[block.tool_use_id, !block.is_error]] : [])));
+        // Do not notify an intended TaskUpdate/TodoWrite before its successful result.
+        // Codex's native plan updates are translated by its protocol adapter into result-less TodoWrite snapshots.
+        const acknowledged = segment.map(turn => ({ ...turn, content: turn.content.filter(block => block.type !== "tool_use"
+                || block.name === "AskUserQuestion" || results.get(block.id) === true
+                || (session.provider === "codex" && block.name === "TodoWrite" && !results.has(block.id))) }));
+        const current = enrichStructuredMessages(acknowledged);
+        const answered = new Set(results.keys());
+        const questions = new Set();
+        const steps = new Map();
+        for (const turn of current)
+            for (const block of turn.content) {
+                if (block.type !== "tool_use")
+                    continue;
+                if (active && block.semantic?.kind === "question_request" && !answered.has(block.id))
+                    questions.add(block.id);
+                if (block.semantic?.kind === "task_list")
+                    for (const item of block.semantic.items)
+                        steps.set(item.id, item.status);
+            }
+        return {
+            semanticPrimed: true, stopNotified: false, employeeId: session.employeeId, active,
+            permission: session.pendingEscalation?.requestId ?? (session.permissionBlocked ? "blocked" : ""), questions,
+            queue: session.queuedMessages?.length ?? 0, candidate: session.employeeCandidateIndex ?? 0,
+            completion: session.completionRevision ?? 0,
+            outcome: session.status === "failed" || session.status === "stopped" ? `${session.status}:${session.endedAt ?? ""}`
+                : session.providerCliActive === false && typeof session.providerCliExitCode === "number" && session.providerCliExitCode !== 0 ? `cli-failed:${session.providerCliExitCode}` : "",
+            turn: `${start}:${messages[start]?.createdAt ?? ""}`, steps,
+        };
+    }
+    remember(map, key, value) {
+        map.delete(key);
+        map.set(key, value);
+        if (map.size > 10_000)
+            map.delete(map.keys().next().value);
+    }
+    send(employeeId, event, context) {
+        try {
+            this.options.im.notify(employeeId, event, { sessionId: context.sessionId, title: context.title?.slice(0, 200) });
+        }
+        catch { /* IM is never an execution outcome */ }
+    }
+}