@co0ontty/wand 4.79.0 → 4.80.0

package/dist/structured-gemini-adapter.js

@@ -0,0 +1,198 @@
+import { spawn } from "node:child_process";
+import { startStructuredCli } from "./structured-exec-pump.js";
+import { asRecord } from "./structured-content.js";
+import { promptWithSystemFallback } from "./structured-provider-common.js";
+/**
+ * Gemini CLI 的会话写在 `~/.gemini/tmp/<project_hash>/chats/`。ID 找不回来时 headless
+ * 会以 42 退出并打印下面这句，识别出来才能丢掉失效的 resume ID 重开一轮
+ * （与 Claude / Pi 的同类兜底一致）。
+ */
+export function isMissingGeminiSession(error) {
+    if (!error)
+        return false;
+    return /Invalid session identifier|No previous sessions found/i.test(error);
+}
+/**
+ * approval mode 映射。结构化 runner 没有权限桥，`default` 下需要确认的工具调用会被
+ * 直接拒绝；`yolo` 才是能连续干活的那一档。
+ */
+export function geminiApprovalMode(session) {
+    if (session.autoApprovePermissions === true
+        || session.mode === "full-access"
+        || session.mode === "managed") {
+        return "yolo";
+    }
+    if (session.mode === "auto-edit")
+        return "auto_edit";
+    return "default";
+}
+/**
+ * `-p ""` 只把 CLI 钉在 headless 模式，真正的 prompt 走 stdin（Gemini CLI 把 stdin
+ * 内容与 `-p` 内容用空行拼接，`-p` 为空时只剩 stdin）。这样长消息不撞 argv 上限，
+ * 也不会出现在 `ps` 里。
+ *
+ * `--skip-trust` 必须带：headless 模式下 Gemini CLI 会检查工作区信任状态，未信任的
+ * 目录会直接以 55 退出，并把 `--approval-mode` 降级成 `default`。Wand 是在用户自己
+ * 选定的工作目录里代表用户启动这个 CLI，与其它 provider 的 auto-approve 语义一致。
+ */
+export function buildGeminiArgs(session) {
+    const args = ["-p", "", "--output-format", "stream-json", "--skip-trust"];
+    const model = session.selectedModel?.trim();
+    if (model && model !== "default")
+        args.push("--model", model);
+    args.push("--approval-mode", geminiApprovalMode(session));
+    if (session.claudeSessionId)
+        args.push("--resume", session.claudeSessionId);
+    return args;
+}
+const GEMINI_TOOL_NAMES = {
+    run_shell_command: "Bash",
+    shell: "Bash",
+    read_file: "Read",
+    read_many_files: "Read",
+    write_file: "Write",
+    replace: "Edit",
+    edit: "Edit",
+    glob: "Glob",
+    list_directory: "Glob",
+    grep_search: "Grep",
+    search_file_content: "Grep",
+    web_search: "WebSearch",
+    google_web_search: "WebSearch",
+    web_fetch: "WebFetch",
+    write_todos: "TodoWrite",
+    todo_write: "TodoWrite",
+    ask_user: "AskUserQuestion",
+    activate_skill: "Skill",
+};
+export function geminiToolName(name) {
+    return GEMINI_TOOL_NAMES[name.toLowerCase()] ?? `Gemini/${name}`;
+}
+function applyGeminiStats(state, stats) {
+    const input = typeof stats.input_tokens === "number" ? stats.input_tokens : 0;
+    const cached = typeof stats.cached === "number" ? stats.cached : 0;
+    const output = typeof stats.output_tokens === "number" ? stats.output_tokens : 0;
+    if (!input && !output)
+        return;
+    state.usage = {
+        inputTokens: Math.max(input - cached, 0),
+        outputTokens: output,
+        cacheReadInputTokens: cached,
+    };
+}
+function geminiToolOutput(event) {
+    if (typeof event.output === "string" && event.output)
+        return event.output;
+    const error = asRecord(event.error);
+    return typeof error?.message === "string" ? error.message : "";
+}
+/**
+ * Apply one Gemini CLI `--output-format stream-json` event.
+ *
+ * assistant `message` 事件带 `delta: true`，每个 chunk 是增量而不是快照，所以文本是
+ * 追加而不是替换。tool_use / tool_result 由 CLI 直接按 tool_id 配对，不需要 upsert。
+ */
+export function applyGeminiEvent(state, event) {
+    const type = typeof event.type === "string" ? event.type : "";
+    if (type === "init") {
+        if (typeof event.session_id === "string" && event.session_id)
+            state.sessionId = event.session_id;
+        if (typeof event.model === "string" && event.model)
+            state.model = event.model;
+        return null;
+    }
+    if (type === "message") {
+        const content = typeof event.content === "string" ? event.content : "";
+        if (event.role !== "assistant" || !content)
+            return null;
+        const previous = state.blocks.at(-1);
+        if (previous?.type === "text")
+            previous.text += content;
+        else
+            state.blocks.push({ type: "text", text: content });
+        state.result += content;
+        return null;
+    }
+    if (type === "tool_use") {
+        const id = typeof event.tool_id === "string" && event.tool_id ? event.tool_id : "tool";
+        const name = typeof event.tool_name === "string" && event.tool_name ? event.tool_name : "tool";
+        state.blocks.push({ type: "tool_use", id, name: geminiToolName(name), input: asRecord(event.parameters) ?? {} });
+        return null;
+    }
+    if (type === "tool_result") {
+        const id = typeof event.tool_id === "string" && event.tool_id ? event.tool_id : "unknown";
+        state.blocks.push({
+            type: "tool_result",
+            tool_use_id: id,
+            content: geminiToolOutput(event),
+            is_error: event.status === "error",
+        });
+        return null;
+    }
+    if (type === "error") {
+        // warning 只是提示（例如循环检测），不应把整轮判成失败。
+        if (event.severity !== "error")
+            return null;
+        return typeof event.message === "string" && event.message ? event.message : "Gemini CLI execution failed";
+    }
+    if (type === "result") {
+        const stats = asRecord(event.stats);
+        if (stats)
+            applyGeminiStats(state, stats);
+        if (event.status === "error") {
+            const error = asRecord(event.error);
+            const message = typeof error?.message === "string" ? error.message : "";
+            return message || "Gemini CLI execution failed";
+        }
+    }
+    return null;
+}
+export class GeminiRunner {
+    spawnProcess;
+    execHost;
+    constructor(spawnProcess = spawn, execHost) {
+        this.spawnProcess = spawnProcess;
+        this.execHost = execHost;
+    }
+    start(context, observer) {
+        const state = {
+            blocks: [],
+            result: "",
+            sessionId: context.session.claudeSessionId,
+            model: context.session.selectedModel ?? context.session.structuredState?.model,
+            phase: "responding",
+        };
+        let primaryError = null;
+        return startStructuredCli({
+            sessionId: context.session.id,
+            file: "gemini",
+            args: buildGeminiArgs(context.session),
+            cwd: context.session.cwd,
+            env: context.env,
+            stdinData: promptWithSystemFallback(context.session, context.prompt),
+            observer,
+            execHost: this.execHost,
+            spawnProcess: this.spawnProcess,
+            createState: () => state,
+            processLine: (line) => {
+                if (!observer.isActive() || !line.trim())
+                    return;
+                try {
+                    const event = JSON.parse(line);
+                    observer.onEvent?.(event);
+                    primaryError = applyGeminiEvent(state, event) ?? primaryError;
+                    observer.onUpdate(state);
+                }
+                catch { /* Gemini stdout is NDJSON; ignore non-protocol noise. */ }
+            },
+            finalize: (ctx, exitCode, signal, spawnError) => ({
+                state,
+                exitCode,
+                signal,
+                stderr: ctx.stderr,
+                primaryError,
+                ...(spawnError ? { spawnError } : {}),
+            }),
+        });
+    }
+}

package/dist/structured-provider-common.d.ts

@@ -1,7 +1,8 @@
 import type { SessionProvider, SessionRunner, SessionSnapshot, StructuredSessionState, WandConfig } from "./types.js";
 /**
  * 把会话级系统提示交给 CLI 的开关。Claude / Qoder / Pi 用 `--append-system-prompt`，
- * Grok 用 `--rules`；Codex / OpenCode 没有这个入口，只能退回并入本轮消息。
+ * Grok 用 `--rules`；Codex / OpenCode / Gemini 没有这个入口，只能退回并入本轮消息
+ * （Gemini 只有 `GEMINI_SYSTEM_MD`，那是整体替换而非追加）。
  * 各 provider 的支持情况由 `--help` 实测得出，新增 provider 前先验。
  */
 export declare function systemPromptFlag(provider: SessionProvider | null | undefined): string | null;

package/dist/structured-provider-common.js

@@ -2,7 +2,8 @@ import { shellQuote } from "./shell-quote.js";
 const NATIVE_THINKING_EFFORT = /^(claude|codex|opencode|grok|qoder|pi):[a-z0-9][a-z0-9_-]{0,31}$/;
 /**
  * 把会话级系统提示交给 CLI 的开关。Claude / Qoder / Pi 用 `--append-system-prompt`，
- * Grok 用 `--rules`；Codex / OpenCode 没有这个入口，只能退回并入本轮消息。
+ * Grok 用 `--rules`；Codex / OpenCode / Gemini 没有这个入口，只能退回并入本轮消息
+ * （Gemini 只有 `GEMINI_SYSTEM_MD`，那是整体替换而非追加）。
  * 各 provider 的支持情况由 `--help` 实测得出，新增 provider 前先验。
  */
 export function systemPromptFlag(provider) {
@@ -82,7 +83,9 @@ export function isStructuredRunnerForProvider(provider, runner) {
         return runner === "grok-cli-headless";
     if (provider === "qoder")
         return runner === "qoder-cli-print";
-    return runner === "pi-cli-json";
+    if (provider === "pi")
+        return runner === "pi-cli-json";
+    return runner === "gemini-cli-json";
 }
 export function defaultStructuredRunner(provider, configuredClaudeRunner = "cli") {
     if (provider === "codex")
@@ -95,6 +98,8 @@ export function defaultStructuredRunner(provider, configuredClaudeRunner = "cli"
         return "qoder-cli-print";
     if (provider === "pi")
         return "pi-cli-json";
+    if (provider === "gemini")
+        return "gemini-cli-json";
     return configuredClaudeRunner === "sdk" ? "claude-sdk" : "claude-cli-print";
 }
 export function resolveStructuredRunner(provider, requestedRunner, configuredClaudeRunner = "cli") {

package/dist/structured-session-manager.d.ts

@@ -3,6 +3,7 @@ import { type WorktreeSetupSpec } from "./git-worktree.js";
 import { SessionLogger } from "./session-logger.js";
 import { WandStorage } from "./storage.js";
 import { ConversationTurn, ExecutionMode, ProcessEvent, SessionProvider, SessionRunner, SessionSnapshot, SessionSource, WandConfig } from "./types.js";
+import type { WandTaskAgent } from "./task-types.js";
 import { type StructuredExecHost } from "./structured-exec-host.js";
 import type { StructuredRunnerAdapter } from "./structured-runner.js";
 export interface StructuredSessionManagerRunners {
@@ -12,6 +13,7 @@ export interface StructuredSessionManagerRunners {
     grok?: StructuredRunnerAdapter;
     qoder?: StructuredRunnerAdapter;
     pi?: StructuredRunnerAdapter;
+    gemini?: StructuredRunnerAdapter;
 }
 interface CreateStructuredSessionOptions {
     cwd: string;
@@ -26,6 +28,11 @@ interface CreateStructuredSessionOptions {
     thinkingEffort?: SessionSnapshot["thinkingEffort"];
     sessionSource?: SessionSource;
     automationId?: string;
+    employeeId?: string;
+    employeeName?: string;
+    employeeAvatar?: string;
+    employeeCandidates?: WandTaskAgent[];
+    employeeCandidateIndex?: number;
     /** 会话级系统提示（团队 / 自动化的角色与规则）；走 provider 的系统提示通道。 */
     systemPrompt?: string;
     /** 所属工作空间 ID（多标签 / 分屏项目）。 */
@@ -108,6 +115,7 @@ export declare class StructuredSessionManager {
     private readonly grokRunner;
     private readonly qoderRunner;
     private readonly piRunner;
+    private readonly geminiRunner;
     /** Structured CLI runs that were mid-flight when the previous web process died. */
     private pendingRecoveryIds;
     private detachedRecoveryPromise;
@@ -154,6 +162,8 @@ export declare class StructuredSessionManager {
         automationId: string;
         title: string;
     }): SessionSnapshot;
+    /** Only an unstarted employee conversation may change CLI after a failed first turn. */
+    private retryEmployeeCandidate;
     /** 往转发会话里追加别的参与者的发言。 */
     appendRelayTurns(id: string, turns: ConversationTurn[]): SessionSnapshot | null;
     sendMessage(id: string, input: string, opts?: {

package/dist/structured-session-manager.js

@@ -4,12 +4,13 @@ import { prepareSessionWorktree } from "./git-worktree.js";
 import { truncateMessagesForTransport } from "./message-truncator.js";
 import { buildChildEnv } from "./env-utils.js";
 import { getErrorMessage } from "./error-utils.js";
+import { getDefaultModelForProvider } from "./config.js";
 import { recordIterationPrompt } from "./iteration-log.js";
 import { signalNameFromNumber } from "./signal-utils.js";
 import { resolveSdkClaudeBinary } from "./claude-sdk-runner.js";
 import { provisionalSessionTopic, SessionTopicCoordinator, sessionTopicBlocklistForSnapshot, shouldAcceptGeneratedSessionTitle, shouldGenerateSessionTopicFromInput, } from "./session-topic.js";
 import { resolveSessionCwd } from "./session-cwd.js";
-import { isSessionProvider } from "./session-provider.js";
+import { isSessionProvider, providerCliCommand } from "./session-provider.js";
 import { resolveSystemAiContext } from "./session-ai-context.js";
 import { CodexRunner } from "./structured-codex-adapter.js";
 import { CodexProtocolReducer } from "./structured-codex-protocol.js";
@@ -21,6 +22,7 @@ import { OpenCodeRunner, applyOpenCodeEvent } from "./structured-opencode-adapte
 import { GrokRunner, applyGrokEvent } from "./structured-grok-adapter.js";
 import { QoderRunner } from "./structured-qoder-adapter.js";
 import { PiRunner, applyPiEvent, isMissingPiSession } from "./structured-pi-adapter.js";
+import { GeminiRunner, applyGeminiEvent, isMissingGeminiSession } from "./structured-gemini-adapter.js";
 import { structuredRunId, } from "./structured-exec-host.js";
 import { defaultStructuredRunner, defaultStructuredState, isStructuredRunnerForProvider, normalizeThinkingEffort, resolveStructuredRunner, } from "./structured-provider-common.js";
 import { enrichStructuredMessages, WAND_PROTOCOL_VERSION } from "./structured-client-protocol.js";
@@ -30,6 +32,13 @@ class PersistedStructuredRunnerError extends Error {
         this.name = "PersistedStructuredRunnerError";
     }
 }
+/** The child process never started, so retrying the same input with another CLI cannot duplicate work. */
+class UnacceptedStructuredSpawnError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UnacceptedStructuredSpawnError";
+    }
+}
 function buildReplayProcessor(session) {
     const runner = session.runner;
     if (runner === "codex-cli-exec") {
@@ -90,7 +99,7 @@ function buildReplayProcessor(session) {
         };
         return processor;
     }
-    // grok-cli-headless / opencode-cli-run / pi-cli-json share the same shape.
+    // grok-cli-headless / opencode-cli-run / pi-cli-json / gemini-cli-json share the same shape.
     const state = {
         blocks: [],
         result: "",
@@ -117,7 +126,9 @@ function buildReplayProcessor(session) {
                 ? applyGrokEvent(state, event)
                 : runner === "opencode-cli-run"
                     ? applyOpenCodeEvent(state, event)
-                    : applyPiEvent(state, event);
+                    : runner === "gemini-cli-json"
+                        ? applyGeminiEvent(state, event)
+                        : applyPiEvent(state, event);
             if (error)
                 processor.primaryError = error;
             return true;
@@ -132,6 +143,7 @@ function recoveredCommandLabel(runner) {
         case "grok-cli-headless": return "grok -p --output-format streaming-json";
         case "qoder-cli-print": return "qodercli -p --output-format stream-json";
         case "pi-cli-json": return "pi --mode json";
+        case "gemini-cli-json": return "gemini -p --output-format stream-json";
         default: return "claude -p";
     }
 }
@@ -211,6 +223,14 @@ function buildStructuredOutputPayload(snapshot) {
         queuedMessageSkills: snapshot.queuedMessageSkills,
         sessionKind: "structured",
         structuredState: snapshot.structuredState,
+        provider: snapshot.provider,
+        runner: snapshot.runner,
+        selectedModel: snapshot.selectedModel,
+        thinkingEffort: snapshot.thinkingEffort,
+        employeeId: snapshot.employeeId,
+        employeeName: snapshot.employeeName,
+        employeeAvatar: snapshot.employeeAvatar,
+        employeeCandidateIndex: snapshot.employeeCandidateIndex,
         title: snapshot.title,
         description: snapshot.description,
         summary: snapshot.description ?? snapshot.summary,
@@ -426,6 +446,7 @@ export class StructuredSessionManager {
     grokRunner;
     qoderRunner;
     piRunner;
+    geminiRunner;
     /** Structured CLI runs that were mid-flight when the previous web process died. */
     pendingRecoveryIds = [];
     detachedRecoveryPromise = null;
@@ -444,6 +465,7 @@ export class StructuredSessionManager {
         this.grokRunner = runners.grok ?? new GrokRunner(undefined, this.execHost);
         this.qoderRunner = runners.qoder ?? new QoderRunner(undefined, this.execHost);
         this.piRunner = runners.pi ?? new PiRunner(undefined, this.execHost);
+        this.geminiRunner = runners.gemini ?? new GeminiRunner(undefined, this.execHost);
         for (const snapshot of this.storage.loadSessions()) {
             if ((snapshot.sessionKind ?? "pty") !== "structured")
                 continue;
@@ -1131,7 +1153,7 @@ export class StructuredSessionManager {
             input,
             cwd: session.cwd,
             language: this.config.language,
-            ai: resolveSystemAiContext(session, this.config),
+            ai: resolveSystemAiContext(session, this.config, this.storage.getSystemSiliconEmployee()),
             onGenerating: (generating) => {
                 if (!this.disposed)
                     this.setSessionTopicGenerating(id, generating);
@@ -1168,6 +1190,11 @@ export class StructuredSessionManager {
             sessionKind: "structured",
             sessionSource: options.sessionSource ?? "interactive",
             automationId: options.automationId,
+            employeeId: options.employeeId,
+            employeeName: options.employeeName,
+            employeeAvatar: options.employeeAvatar,
+            employeeCandidates: options.employeeCandidates,
+            employeeCandidateIndex: options.employeeCandidateIndex,
             systemPrompt: options.systemPrompt?.trim() || null,
             workspaceId: options.workspaceId,
             workspaceTaskId: options.workspaceTaskId,
@@ -1183,9 +1210,11 @@ export class StructuredSessionManager {
                             ? "qodercli -p --output-format stream-json"
                             : provider === "pi"
                                 ? "pi --mode json --print"
-                                : runner === "claude-sdk"
-                                    ? "claude-agent-sdk (stream-json)"
-                                    : "claude -p --output-format stream-json",
+                                : provider === "gemini"
+                                    ? "gemini -p --output-format stream-json"
+                                    : runner === "claude-sdk"
+                                        ? "claude-agent-sdk (stream-json)"
+                                        : "claude -p --output-format stream-json",
             cwd: worktreeSetup?.cwd ?? baseCwd,
             mode: options.mode,
             worktreeEnabled: Boolean(worktreeSetup),
@@ -1238,6 +1267,49 @@ export class StructuredSessionManager {
         this.emitStructuredSnapshot(titled);
         return titled;
     }
+    /** Only an unstarted employee conversation may change CLI after a failed first turn. */
+    retryEmployeeCandidate(id, original, prompt, error, skills) {
+        const candidates = original.employeeCandidates ?? [];
+        const nextIndex = (original.employeeCandidateIndex ?? 0) + 1;
+        if (!original.employeeId || (original.messages?.length ?? 0) !== 0 || nextIndex >= candidates.length)
+            return null;
+        const current = this.sessions.get(id);
+        if (!current || (current.status !== "running" && current.status !== "failed"))
+            return null;
+        if ((current.messages ?? []).length !== 1 || current.messages?.[0]?.role !== "user")
+            return null;
+        if (!(error instanceof UnacceptedStructuredSpawnError))
+            return null;
+        const next = candidates[nextIndex];
+        const runner = resolveStructuredRunner(next.provider, undefined, this.config.structuredRunner);
+        const model = next.model === "default"
+            ? getDefaultModelForProvider(this.config, next.provider) || null
+            : next.model;
+        const retry = {
+            ...current,
+            provider: next.provider,
+            runner,
+            command: providerCliCommand(next.provider),
+            mode: next.mode,
+            autoApprovePermissions: shouldAutoApproveForMode(next.mode),
+            selectedModel: model,
+            thinkingEffort: next.thinkingEffort,
+            employeeCandidateIndex: nextIndex,
+            claudeSessionId: null,
+            messages: [],
+            status: "idle",
+            exitCode: null,
+            endedAt: null,
+            structuredState: {
+                ...defaultStructuredState(next.provider, runner),
+                model: model ?? undefined,
+            },
+        };
+        this.sessions.set(id, retry);
+        this.saveAuthoritativeSession(retry);
+        this.emitStructuredSnapshot(retry);
+        return this.sendMessage(id, prompt, { skills });
+    }
     /** 往转发会话里追加别的参与者的发言。 */
     appendRelayTurns(id, turns) {
         const session = this.sessions.get(id);
@@ -1405,7 +1477,8 @@ export class StructuredSessionManager {
                 content: [{ type: "text", text: prompt }],
             };
         const requestId = randomUUID();
-        if (session.provider === "pi" && isMissingPiSession(session.structuredState?.lastError, session.claudeSessionId)) {
+        if ((session.provider === "pi" && isMissingPiSession(session.structuredState?.lastError, session.claudeSessionId))
+            || (session.provider === "gemini" && isMissingGeminiSession(session.structuredState?.lastError))) {
             session = { ...session, claudeSessionId: null };
         }
         const updated = {
@@ -1472,6 +1545,15 @@ export class StructuredSessionManager {
                     installHint: "请安装 @earendil-works/pi-coding-agent（或兼容的 Pi CLI），或重跑 `wand service:install` 刷新服务的 PATH",
                 });
             }
+            else if (provider === "gemini") {
+                await this.runClaudeStreaming(id, updated, prompt, requestId, {
+                    runner: this.geminiRunner,
+                    provider: "gemini",
+                    commandLabel: "gemini -p --output-format stream-json",
+                    logKind: "gemini-json",
+                    installHint: "请安装 @google/gemini-cli ≥ 0.11（`npm i -g @google/gemini-cli@latest`），或重跑 `wand service:install` 刷新服务的 PATH",
+                });
+            }
             else if (runner === "claude-sdk") {
                 await this.runClaudeSdkStreaming(id, updated, prompt, requestId, skills);
             }
@@ -1486,8 +1568,12 @@ export class StructuredSessionManager {
             // Close handlers use this tagged error after they have already persisted
             // the detailed failure. Re-throw even if an ended-event listener removed
             // the session synchronously; there is no request-id marker to leak.
-            if (error instanceof PersistedStructuredRunnerError)
+            if (error instanceof PersistedStructuredRunnerError) {
+                const retry = this.retryEmployeeCandidate(id, session, prompt, error, skills);
+                if (retry)
+                    return await retry;
                 throw error;
+            }
             const current = this.sessions.get(id);
             if (!current)
                 throw error;
@@ -1496,6 +1582,9 @@ export class StructuredSessionManager {
             if (!this.isCurrentRequest(id, requestId)) {
                 return current;
             }
+            const retry = this.retryEmployeeCandidate(id, session, prompt, error, skills);
+            if (retry)
+                return await retry;
             this.settlePendingPermission(id, undefined, structuredPermissionDenied("会话执行失败"));
             this.turnApprovalMemory.delete(id);
             const failed = {
@@ -2202,7 +2291,7 @@ export class StructuredSessionManager {
             const hint = result.spawnError.code === "ENOENT"
                 ? "（PATH 中找不到 codex 可执行文件；请确认 codex 已安装，或重跑 `wand service:install` 刷新服务的 PATH）"
                 : "";
-            throw new Error(`codex exec 启动失败：${result.spawnError.message}${hint}`);
+            throw new UnacceptedStructuredSpawnError(`codex exec 启动失败：${result.spawnError.message}${hint}`);
         }
         this.logger?.appendStructuredSpawn(sessionId, {
             kind: "codex-exec-close",
@@ -2348,7 +2437,7 @@ export class StructuredSessionManager {
             const hint = result.spawnError.code === "ENOENT"
                 ? "（PATH 中找不到 grok；请安装 Grok Build CLI，或重跑 `wand service:install` 刷新服务 PATH）"
                 : "";
-            throw new Error(`grok 启动失败：${result.spawnError.message}${hint}`);
+            throw new UnacceptedStructuredSpawnError(`grok 启动失败：${result.spawnError.message}${hint}`);
         }
         this.logger?.appendStructuredSpawn(sessionId, {
             kind: "grok-headless-close",
@@ -2496,7 +2585,7 @@ export class StructuredSessionManager {
             const hint = result.spawnError.code === "ENOENT"
                 ? "（PATH 中找不到 opencode；请安装 opencode-ai，或重跑 `wand service:install` 刷新服务 PATH）"
                 : "";
-            throw new Error(`opencode run 启动失败：${result.spawnError.message}${hint}`);
+            throw new UnacceptedStructuredSpawnError(`opencode run 启动失败：${result.spawnError.message}${hint}`);
         }
         this.logger?.appendStructuredSpawn(sessionId, {
             kind: "opencode-run-close",
@@ -2673,9 +2762,9 @@ export class StructuredSessionManager {
         flushEmit();
         if (result.spawnError) {
             const hint = result.spawnError.code === "ENOENT"
-                ? `（PATH 中找不到 ${provider === "qoder" ? "qodercli" : provider === "pi" ? "pi" : "claude"} 可执行文件；${options.installHint ?? "请确认 claude 已安装，或重跑 `wand service:install` 刷新服务的 PATH"}）`
+                ? `（PATH 中找不到 ${provider === "qoder" ? "qodercli" : provider === "gemini" ? "gemini" : provider === "pi" ? "pi" : "claude"} 可执行文件；${options.installHint ?? "请确认 claude 已安装，或重跑 `wand service:install` 刷新服务的 PATH"}）`
                 : "";
-            throw new Error(`${commandLabel} 启动失败：${result.spawnError.message}${hint}`);
+            throw new UnacceptedStructuredSpawnError(`${commandLabel} 启动失败：${result.spawnError.message}${hint}`);
         }
         this.logger?.appendStructuredSpawn(sessionId, {
             kind: `${logKind}-close`,
@@ -2706,6 +2795,9 @@ export class StructuredSessionManager {
             if (provider === "pi" && isMissingPiSession(result.stderr, current.claudeSessionId)) {
                 failed.claudeSessionId = null;
             }
+            if (provider === "gemini" && isMissingGeminiSession(`${result.stderr}\n${errorText}`)) {
+                failed.claudeSessionId = null;
+            }
             this.sessions.set(sessionId, failed);
             this.saveAuthoritativeSession(failed);
             this.emitStructuredSnapshot(failed);

package/dist/system-ai.js

@@ -260,7 +260,7 @@ export function discoverCliSystemAiConfigs(preferred, home = os.homedir()) {
     const found = [];
     const seen = new Set();
     for (const provider of [...new Set(order)]) {
-        if (provider === "qoder" || provider === "pi")
+        if (provider === "qoder" || provider === "pi" || provider === "gemini")
             continue;
         let discovered;
         try {

package/dist/system-employee.d.ts

@@ -0,0 +1,35 @@
+import { SYSTEM_EMPLOYEE_ID, SYSTEM_EMPLOYEE_KEY, SYSTEM_EMPLOYEE_NAME, SYSTEM_EMPLOYEE_TAG, isSystemSiliconEmployee, type SiliconEmployee } from "./ai-team-types.js";
+import { type WandTaskAgent } from "./task-types.js";
+import type { AiCliCandidate, SessionProvider } from "./types.js";
+export { SYSTEM_EMPLOYEE_ID, SYSTEM_EMPLOYEE_KEY, SYSTEM_EMPLOYEE_NAME, SYSTEM_EMPLOYEE_TAG, isSystemSiliconEmployee, };
+/**
+ * 内置的「系统运维」员工。
+ *
+ * Wand 自己的 AI 调用（commit message / tag、提示词优化、会话与任务标题、
+ * 员工起草）都由这位员工执行：名字、职责与人设写死在代码里，不可编辑、不可归档、
+ * 不可删除；只有执行候选（CLI 工具 + 模型 + 思考深度，按顺序降级）由用户维护。
+ */
+export declare const SYSTEM_EMPLOYEE_DUTY = "Wand \u7CFB\u7EDF\u8FD0\u7EF4\uFF1A\u670D\u52A1\u4E0E CLI \u7EBF\u8DEF\u3001\u66F4\u65B0\u5206\u53D1\u3001\u4ED3\u5E93\u4E0E\u4F1A\u8BDD\u64CD\u4F5C\uFF0CWand \u81EA\u6709 AI \u4EFB\u52A1\u7684\u6267\u884C\u8005\u3002";
+/**
+ * 同时承担两个角色，所以规则写在一起：
+ *   - 作为会话系统提示：用户直接找它做运维/功能实现；
+ *   - 作为内部 AI 调用的系统提示：任务通常带严格输出格式。
+ */
+export declare const SYSTEM_EMPLOYEE_PROMPT: string;
+export interface SystemEmployeeSeed {
+    /** 老配置里的「系统 AI 专用工具」；没有时跟随默认 provider。 */
+    cli?: SessionProvider | null;
+    /** 该工具下的模型；空 / "default" 表示跟随 provider 默认模型。 */
+    model?: string | null;
+    /** 没有专用工具时的默认 provider。 */
+    provider?: SessionProvider | null;
+}
+/** 首次创建内置员工时使用的候选：优先沿用用户已有的系统 AI 工具与模型。 */
+export declare function systemEmployeeSeedAgents(seed?: SystemEmployeeSeed): WandTaskAgent[];
+export declare function systemEmployeeDefinition(agents: WandTaskAgent[], now: string, existing?: SiliconEmployee | null): SiliconEmployee;
+/** 内置员工只保留结构化候选（会话与内部 AI 调用都要求结构化执行）。 */
+export declare function systemEmployeeAgentsOrNull(value: unknown): WandTaskAgent[] | null;
+/**
+ * 内部 AI 调用的 CLI 降级链：按用户设置的顺序，模型为空 / "default" 时跟随 provider 默认值。
+ */
+export declare function systemEmployeeCliCandidates(employee: Pick<SiliconEmployee, "agents"> | null | undefined): AiCliCandidate[];