@co0ontty/wand 4.93.0 → 4.94.0

package/dist/pi-model-discovery.js

@@ -5,7 +5,6 @@ import { isRecord } from "./object-utils.js";
 const MODEL_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,127}$/;
 const SUPPORTED_APIS = new Set([
     "anthropic-messages",
-    "google-generative-ai",
     "openai-completions",
     "openai-responses",
 ]);
@@ -61,9 +60,6 @@ function endpointUrl(baseUrl, api) {
         if (api === "anthropic-messages") {
             suffix = /\/v\d+(?:beta)?$/i.test(basePath) ? "models" : "v1/models";
         }
-        else if (api === "google-generative-ai") {
-            suffix = /\/v\d+(?:beta)?$/i.test(basePath) ? "models" : "v1beta/models";
-        }
         else {
             suffix = "models";
         }
@@ -135,8 +131,6 @@ function asModelId(value, api) {
     if (typeof value !== "string")
         return "";
     const trimmed = value.trim();
-    if (api === "google-generative-ai")
-        return trimmed.replace(/^models\//, "");
     return trimmed;
 }
 function parseEndpointPage(api, body, provider) {
@@ -149,23 +143,20 @@ function parseEndpointPage(api, body, provider) {
     for (const row of rows) {
         if (!isRecord(row))
             continue;
-        const id = asModelId(api === "google-generative-ai" ? row.name : row.id, api);
+        const id = asModelId(row.id, api);
         const qualifiedId = `${provider}/${id}`;
         if (!id || id.length > 128 || !MODEL_ID_PATTERN.test(id) || !MODEL_ID_PATTERN.test(qualifiedId))
             continue;
         const displayName = typeof row.display_name === "string" ? row.display_name.trim()
             : typeof row.displayName === "string" ? row.displayName.trim()
-                : typeof row.name === "string" && api !== "google-generative-ai" ? row.name.trim() : "";
+                : typeof row.name === "string" ? row.name.trim() : "";
         models.push({
             id: qualifiedId,
             label: displayName && displayName !== id ? `${displayName} · ${qualifiedId}` : qualifiedId,
         });
     }
     let nextCursor = "";
-    if (api === "google-generative-ai") {
-        nextCursor = typeof body.nextPageToken === "string" ? body.nextPageToken : "";
-    }
-    else if (body.has_more === true) {
+    if (body.has_more === true) {
         const lastRow = rows.at(-1);
         const lastRowId = isRecord(lastRow) && typeof lastRow.id === "string" ? lastRow.id : "";
         nextCursor = typeof body.last_id === "string" ? body.last_id : lastRowId;
@@ -177,8 +168,7 @@ function pageUrl(endpoint, cursor) {
     if (!url)
         return null;
     if (cursor) {
-        const key = endpoint.api === "google-generative-ai" ? "pageToken"
-            : endpoint.api === "anthropic-messages" ? "after_id" : "after";
+        const key = endpoint.api === "anthropic-messages" ? "after_id" : "after";
         url.searchParams.set(key, cursor);
     }
     return url;
@@ -214,9 +204,7 @@ async function fetchEndpointModels(endpoint, fetchImpl) {
             break;
         const headers = { ...endpoint.headers };
         if (endpoint.apiKey) {
-            if (endpoint.api === "google-generative-ai")
-                headers["x-goog-api-key"] = endpoint.apiKey;
-            else if (endpoint.api === "anthropic-messages") {
+            if (endpoint.api === "anthropic-messages") {
                 headers["x-api-key"] = endpoint.apiKey;
                 headers["anthropic-version"] = "2023-06-01";
             }

package/dist/pi-resource-recommendation.d.ts

@@ -18,7 +18,7 @@ export declare function decidePiCodemode(input: {
     caller: string;
     signal?: AbortSignal;
 }): Promise<PiAutomaticCodemodeChoice>;
-/** Read-only matching. Results never modify settings, connect MCP, or authorize an operation. */
+/** Read-only matching. Bounded system-role decisions rank the candidate set; they never connect MCP or grant authority. */
 export declare function recommendPiResources(input: {
     prompt: string;
     candidates: PiResourceSelection;

package/dist/pi-resource-recommendation.js

@@ -48,14 +48,6 @@ function resourceTask(prompt, catalog) {
     const task = clauses.filter((clause) => !switchOnly.test(clause.trim()));
     return task.length === clauses.length ? prompt : task.filter((clause) => clause.trim()).join("，").trim();
 }
-const MATCH_INSTRUCTIONS = "Which skill fits the task?";
-/** Keep the task separate from skill marketing text; the small model overweights long descriptions. */
-function shortlistQuestions(name) {
-    return {
-        forward: { type: "choice", instructions: MATCH_INSTRUCTIONS, criteria: { match: name, none: "None" } },
-        reverse: { type: "choice", instructions: MATCH_INSTRUCTIONS, criteria: { none: "None", match: name } },
-    };
-}
 function matchProbability(result, id) {
     const answer = result.answers[id];
     const probabilities = answer?.probabilities;
@@ -105,9 +97,89 @@ export async function decidePiCodemode(input) {
         return { override: "off", source: "local" };
     return { source: "uncertain" };
 }
-/** Read-only matching. Results never modify settings, connect MCP, or authorize an operation. */
+const SKILL_GROUP_SIZE = 4;
+const SKILL_GROUPS_PER_REQUEST = 4;
+const SKILL_DESCRIPTION_CHARS = 48;
+const NO_SKILL = "none";
+function compactSkillDescription(item) {
+    const description = item.description.replace(/\s+/g, " ").trim();
+    return `${item.name}: ${Array.from(description).slice(0, SKILL_DESCRIPTION_CHARS).join("")}`;
+}
+function skillDecisionGroup(items, index) {
+    return { candidates: items.map((item, option) => ({ item, option: `s${option}` })),
+        forwardId: `g${index}f`, reverseId: `g${index}r` };
+}
+function skillDecisionCriteria(group, reverse) {
+    const entries = group.candidates.map((candidate) => [candidate.option, compactSkillDescription(candidate.item)]);
+    entries.push([NO_SKILL, "No installed skill is relevant"]);
+    if (reverse)
+        entries.reverse();
+    return Object.fromEntries(entries);
+}
+function skillDecisionQuestions(groups) {
+    const questions = {};
+    for (const group of groups) {
+        questions[group.forwardId] = { type: "choice", instructions: "Which installed skill best fits the task?",
+            criteria: skillDecisionCriteria(group, false) };
+        questions[group.reverseId] = { type: "choice", instructions: "Which installed skill best fits the task?",
+            criteria: skillDecisionCriteria(group, true) };
+    }
+    return questions;
+}
+function readSkillChoice(result, id, labels) {
+    const answer = result.answers[id];
+    const probabilities = answer?.probabilities;
+    const values = labels.map((label) => probabilities?.[label]);
+    if (answer?.type !== "choice" || typeof answer.choice !== "string" || !labels.includes(answer.choice)
+        || !probabilities || Object.keys(probabilities).length !== labels.length
+        || values.some((value) => typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1)
+        || Math.abs(values.reduce((sum, value) => sum + value, 0) - 1) > 0.002
+        || probabilities[answer.choice] < Math.max(...values)) {
+        throw new DecisionError("INVALID_RESULT", "决策员工返回无效的 Skills 候选判断，原选择未改变。", 502);
+    }
+    return { choice: answer.choice, probabilities: probabilities };
+}
+function readSkillPair(result, group) {
+    const labels = [...group.candidates.map((candidate) => candidate.option), NO_SKILL];
+    return { group, forward: readSkillChoice(result, group.forwardId, labels),
+        reverse: readSkillChoice(result, group.reverseId, labels) };
+}
+function averageSkillScore(pair, option) {
+    return (pair.forward.probabilities[option] + pair.reverse.probabilities[option]) / 2;
+}
+function strongestSkill(pair) {
+    let winner = pair.group.candidates[0];
+    let score = -1;
+    for (const candidate of pair.group.candidates) {
+        const next = averageSkillScore(pair, candidate.option);
+        if (next > score) {
+            winner = candidate;
+            score = next;
+        }
+    }
+    return winner.item;
+}
+/** Average the two reversed option orders; an exact aggregate tie is not actionable. */
+function strongestSkillOption(pair) {
+    let winner = null;
+    let score = -1;
+    let tied = false;
+    for (const option of [...pair.group.candidates.map((candidate) => candidate.option), NO_SKILL]) {
+        const next = averageSkillScore(pair, option);
+        if (next > score + Number.EPSILON) {
+            winner = option;
+            score = next;
+            tied = false;
+        }
+        else if (Math.abs(next - score) <= Number.EPSILON)
+            tied = true;
+    }
+    return tied ? null : winner;
+}
+/** Read-only matching. Bounded system-role decisions rank the candidate set; they never connect MCP or grant authority. */
 export async function recommendPiResources(input) {
-    const resources = [];
+    const statuses = new Map();
+    const semanticSkills = [];
     const task = resourceTask(input.prompt, input.catalog);
     let calls = 0;
     for (const kind of ["skills", "mcpServers"]) {
@@ -119,48 +191,63 @@ export async function recommendPiResources(input) {
                 throw new DecisionError("RESOURCE_MISSING", "候选资源已移除，请重新打开设置面板。");
             const mention = explicitMention(input.prompt, item.name);
             if (mention) {
-                resources.push({ id, kind, status: mention === "included" ? "recommended" : "unmatched", source: "explicit" });
-                continue;
+                statuses.set(id, { id, kind, status: mention === "included" ? "recommended" : "unmatched", source: "explicit" });
             }
-            // Transport type is not a description of a server's capabilities. Never connect for discovery.
-            if (!task || kind === "mcpServers" || item.description.length > 1000) {
-                resources.push({ id, kind, status: "unassessed", source: "local" });
-                continue;
+            else if (!task || kind === "mcpServers" || item.description.length > 1000) {
+                // Transport type is not a capability description. Never connect MCP for discovery.
+                statuses.set(id, { id, kind, status: "unassessed", source: "local" });
             }
-            let result;
-            try {
-                calls++;
-                const shortlist = await input.evaluate({ state: task, questions: shortlistQuestions(item.name) }, input.caller, input.signal);
-                const forward = matchProbability(shortlist, "forward");
-                const reverse = matchProbability(shortlist, "reverse");
-                if (forward < 0.8 || reverse < 0.8) {
-                    resources.push({ id, kind, status: forward <= 0.2 && reverse <= 0.2 ? "unmatched" : "uncertain", source: "local" });
-                    continue;
-                }
+            else {
+                semanticSkills.push(item);
+            }
+        }
+    }
+    if (semanticSkills.length) {
+        try {
+            const groups = Array.from({ length: Math.ceil(semanticSkills.length / SKILL_GROUP_SIZE) }, (_, index) => skillDecisionGroup(semanticSkills.slice(index * SKILL_GROUP_SIZE, (index + 1) * SKILL_GROUP_SIZE), index));
+            const pairs = [];
+            for (let index = 0; index < groups.length; index += SKILL_GROUPS_PER_REQUEST) {
                 if (input.signal?.aborted)
                     throw new DecisionError("CANCELLED", "推荐已取消。", 499);
-                // A name match alone cannot load a skill. Confirm against its complete description.
+                const batch = groups.slice(index, index + SKILL_GROUPS_PER_REQUEST);
                 calls++;
-                result = await input.evaluate({
-                    state: { task, resource: { name: item.name, description: item.description } },
-                    questions: { relevant: { type: "noul", instructions: "Does this skill match the task?" } },
-                }, input.caller, input.signal);
+                const result = await input.evaluate({ state: task, questions: skillDecisionQuestions(batch) }, input.caller, input.signal);
+                if (input.signal?.aborted)
+                    throw new DecisionError("CANCELLED", "推荐已取消。", 499);
+                pairs.push(...batch.map((group) => readSkillPair(result, group)));
             }
-            catch (error) {
-                if (error instanceof DecisionError && ["CONTEXT_LIMIT", "QUESTION_LIMIT", "OPTIONS_COLLAPSED"].includes(error.code)) {
-                    resources.push({ id, kind, status: "unassessed", source: "local" });
-                    continue;
-                }
-                throw error;
+            let finalPair;
+            if (pairs.length === 1) {
+                finalPair = pairs[0];
             }
-            const relevant = result.answers.relevant?.noul;
-            if (typeof relevant !== "number" || !Number.isFinite(relevant) || relevant < 0 || relevant > 1) {
-                throw new DecisionError("INVALID_RESULT", "本地模型返回无效判断，原选择未改变。", 502);
+            else {
+                const finalists = pairs.map(strongestSkill);
+                const finalGroup = skillDecisionGroup(finalists, groups.length);
+                calls++;
+                const result = await input.evaluate({ state: task, questions: skillDecisionQuestions([finalGroup]) }, input.caller, input.signal);
+                if (input.signal?.aborted)
+                    throw new DecisionError("CANCELLED", "推荐已取消。", 499);
+                finalPair = readSkillPair(result, finalGroup);
             }
-            const status = relevant >= 0.8 ? "recommended" : relevant <= 0.2 ? "unmatched" : "uncertain";
-            resources.push({ id, kind, status, source: "local" });
+            const winner = strongestSkillOption(finalPair);
+            const selected = winner && winner !== NO_SKILL
+                ? finalPair.group.candidates.find((candidate) => candidate.option === winner)?.item.id : undefined;
+            for (const item of semanticSkills)
+                statuses.set(item.id, { id: item.id, kind: "skills",
+                    status: item.id === selected ? "recommended" : winner === NO_SKILL ? "unmatched" : "uncertain", source: "local" });
+        }
+        catch (error) {
+            if (!(error instanceof DecisionError) || !["CONTEXT_LIMIT", "QUESTION_LIMIT", "OPTIONS_COLLAPSED"].includes(error.code))
+                throw error;
+            for (const item of semanticSkills)
+                statuses.set(item.id, { id: item.id, kind: "skills", status: "unassessed", source: "local" });
         }
     }
+    const resources = [];
+    for (const kind of ["skills", "mcpServers"]) {
+        for (const id of input.candidates[kind])
+            resources.push(statuses.get(id));
+    }
     const selection = { skills: [], mcpServers: [] };
     for (const resource of resources)
         if (resource.status === "recommended")

package/dist/process-manager-native-history.js

@@ -4,6 +4,7 @@ import process from "node:process";
 import os from "node:os";
 import { DatabaseSync } from "node:sqlite";
 import { getProviderResumeCommandSessionId } from "./resume-policy.js";
+import { parseTimestampMs as parseTimeMs } from "./time-utils.js";
 const REAL_CONVERSATION_MIN_LINES = 2;
 const DISCOVERY_RECENT_WINDOW_MS = 10 * 60 * 1000;
 const START_TIME_SKEW_MS = 30 * 1000;
@@ -173,12 +174,6 @@ function isSameResolvedPath(left, right) {
 function isUsableCodexHistorySession(session) {
     return session.hasUser || session.hasConversation;
 }
-function parseTimeMs(value) {
-    if (!value)
-        return null;
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : null;
-}
 function selectCodexSessionForRecord(record, sessions) {
     const knownMtimes = record.knownCodexSessionMtimes ?? new Map();
     const candidates = sessions

package/dist/process-manager.d.ts

@@ -243,7 +243,6 @@ export declare class ProcessManager extends EventEmitter {
     deleteQoderHistoryFiles(sessionIds: string[]): number;
     deletePiHistoryFiles(sessionIds: string[]): number;
     deleteGrokHistoryFiles(sessionIds: string[]): number;
-    deleteGeminiHistoryFiles(sessionIds: string[]): number;
     private captureCodexSessionId;
     private captureOpenCodeSessionId;
     private captureClaudeSessionId;

package/dist/process-manager.js

@@ -674,6 +674,9 @@ export class ProcessManager extends EventEmitter {
     async start(command, cwd, mode, initialInput, opts) {
         if (this.disposed)
             throw new Error("ProcessManager has been disposed.");
+        if (opts?.provider != null && !isSessionProvider(opts.provider)) {
+            throw new Error(`不支持的终端 provider：${String(opts.provider)}`);
+        }
         const id = opts?.reuseId || randomUUID();
         // Host operations are keyed by session id, not by the manager record. A
         // second handshake must not adopt/forget a cancelled first incarnation.
@@ -798,10 +801,10 @@ export class ProcessManager extends EventEmitter {
             ? getProviderCommandSessionId(provider, processedCommand)
                 ?? getProviderCommandSessionId(provider, command)
             : null;
-        // Grok / Qoder / Gemini accept caller-selected IDs for new conversations. Assigning
+        // Grok / Qoder accept caller-selected IDs for new conversations. Assigning
         // one up front avoids depending on provider-specific TUI rendering to learn
         // the durable ID later.
-        const assignedProviderSessionId = !existingProviderSessionId && (provider === "grok" || provider === "qoder" || provider === "gemini")
+        const assignedProviderSessionId = !existingProviderSessionId && (provider === "grok" || provider === "qoder")
             ? randomUUID()
             : null;
         if (assignedProviderSessionId) {
@@ -1129,9 +1132,6 @@ export class ProcessManager extends EventEmitter {
     deleteGrokHistoryFiles(sessionIds) {
         return this.providerHistory.deleteGrokHistoryFiles(sessionIds);
     }
-    deleteGeminiHistoryFiles(sessionIds) {
-        return this.providerHistory.deleteGeminiHistoryFiles(sessionIds);
-    }
     captureCodexSessionId(record, options) {
         if (record.provider !== "codex" || record.claudeSessionId) {
             return false;
@@ -2263,19 +2263,6 @@ export class ProcessManager extends EventEmitter {
                 result += ` --thinking '${level}'`;
             return result;
         }
-        if (provider === "gemini") {
-            let result = command;
-            const trimmedModel = model?.trim();
-            if (trimmedModel && trimmedModel !== "default" && !/--model(?:\s|=)/.test(result) && !/(?:^|\s)-m(?:\s|$)/.test(result)) {
-                result += ` --model '${trimmedModel.replace(/'/g, "'\\''")}'`;
-            }
-            // Gemini CLI 没有 thinking 档位开关。approval mode 与其它 provider 的
-            // auto-approve 语义对齐，default 下让 TUI 自己弹确认。
-            if ((mode === "managed" || mode === "full-access" || mode === "auto-edit") && !/--approval-mode(?:\s|=)/.test(result) && !/(?:^|\s)-y(?:\s|$)/.test(result)) {
-                result += " --approval-mode yolo";
-            }
-            return result;
-        }
         const isClaudeCmd = /^(?:claude|npx\s+claude|[^\s]+\/claude)(?:\s|$)/.test(command);
         if (!isClaudeCmd)
             return command;

package/dist/provider-catalog.d.ts

@@ -6,11 +6,10 @@
  * 都直接复用它，避免同一个 provider 概念散落在两处各写一份。
  */
 /** 全部受支持的会话 provider；顺序即 UI / 派发选择器里的展示顺序。 */
-export declare const SESSION_PROVIDERS: readonly ["claude", "codex", "opencode", "grok", "qoder", "pi", "gemini"];
+export declare const SESSION_PROVIDERS: readonly ["claude", "codex", "opencode", "grok", "qoder", "pi"];
 export type SessionProvider = (typeof SESSION_PROVIDERS)[number];
 /**
  * 拥有原生思考档位（`provider:level`）的 provider。
- * Gemini CLI 没有档位开关，所以不出现在这里：`gemini:max` 这种值不应该被当成合法档位保留。
  */
 export declare const NATIVE_THINKING_EFFORT_PROVIDERS: readonly ["claude", "codex", "opencode", "grok", "qoder", "pi"];
 /** 原生思考档位的 `provider:level` 形状；各端必须共用同一张 provider 名单。 */

package/dist/provider-catalog.js

@@ -6,10 +6,9 @@
  * 都直接复用它，避免同一个 provider 概念散落在两处各写一份。
  */
 /** 全部受支持的会话 provider；顺序即 UI / 派发选择器里的展示顺序。 */
-export const SESSION_PROVIDERS = ["claude", "codex", "opencode", "grok", "qoder", "pi", "gemini"];
+export const SESSION_PROVIDERS = ["claude", "codex", "opencode", "grok", "qoder", "pi"];
 /**
  * 拥有原生思考档位（`provider:level`）的 provider。
- * Gemini CLI 没有档位开关，所以不出现在这里：`gemini:max` 这种值不应该被当成合法档位保留。
  */
 export const NATIVE_THINKING_EFFORT_PROVIDERS = ["claude", "codex", "opencode", "grok", "qoder", "pi"];
 /** 原生思考档位的 `provider:level` 形状；各端必须共用同一张 provider 名单。 */
@@ -41,7 +40,6 @@ export const PROVIDER_LABELS = {
     grok: "Grok",
     qoder: "Qoder",
     pi: "Pi",
-    gemini: "Gemini",
 };
 /**
  * Wand 自带 Agent（进程内 `core` harness / SDK）的展示名。
@@ -79,9 +77,6 @@ export const PROVIDER_ALIASES = {
     pi: "pi",
     "pi-cli": "pi",
     "pi-cli-json": "pi",
-    gemini: "gemini",
-    "gemini-cli": "gemini",
-    "gemini-cli-json": "gemini",
 };
 /** 归一化一个已持久化的 provider id 或 runner/别名；无法识别时返回 null。 */
 export function normalizeProviderId(value) {

package/dist/provider-cli-updater.js

@@ -63,14 +63,6 @@ const PROVIDER_CLI_SPECS = [
         versionArgs: ["--version"],
         updateArgs: ["update", "self"],
     },
-    {
-        id: "gemini",
-        label: "Gemini CLI",
-        command: "gemini",
-        npmPackage: "@google/gemini-cli",
-        versionArgs: ["--version"],
-        // 没有 `gemini update` 子命令，只能走 npm 发布渠道。
-    },
 ];
 async function runCommand(command, args, timeout, options) {
     const { stdout, stderr } = await execFileAsync(command, args, {
@@ -351,7 +343,7 @@ export async function updateProviderClis(statuses, ids, options = {}) {
                 output = await runCommand(executable, spec.updateArgs, options.updateTimeoutMs ?? UPDATE_TIMEOUT_MS, options);
             }
             else {
-                // 没有自更新子命令的 CLI（Gemini）走它的 npm 发布渠道。
+                // 没有自更新子命令的 CLI 走它的 npm 发布渠道。
                 output = await runCommand(npmBin(options), ["install", "-g", `${spec.npmPackage}@latest`], options.updateTimeoutMs ?? UPDATE_TIMEOUT_MS, options);
             }
             if (spec.id === "codex") {

package/dist/provider-history-scanner.d.ts

@@ -50,7 +50,6 @@ export interface ProviderHistoryScannerOptions {
     qoderProjectsDirs?: string[];
     piSessionsDir?: string;
     grokSessionsDir?: string;
-    geminiHome?: string;
 }
 /**
  * Incremental provider-history index. Directory entries are refreshed on each
@@ -64,7 +63,6 @@ export declare class ProviderHistoryScanner {
     private readonly qoderProjectsDirs;
     private readonly piSessionsDir;
     private readonly grokSessionsDir;
-    private readonly geminiHome;
     private readonly claudeIndex;
     private readonly codexIndex;
     private readonly qoderIndex;
@@ -96,5 +94,4 @@ export declare class ProviderHistoryScanner {
     deleteQoderHistoryFiles(sessionIds: string[]): number;
     deletePiHistoryFiles(sessionIds: string[]): number;
     deleteGrokHistoryFiles(sessionIds: string[]): number;
-    deleteGeminiHistoryFiles(sessionIds: string[]): number;
 }

package/dist/provider-history-scanner.js

@@ -266,7 +266,6 @@ export class ProviderHistoryScanner {
     qoderProjectsDirs;
     piSessionsDir;
     grokSessionsDir;
-    geminiHome;
     claudeIndex = new Map();
     codexIndex = new Map();
     qoderIndex = new Map();
@@ -285,7 +284,6 @@ export class ProviderHistoryScanner {
         ];
         this.piSessionsDir = options.piSessionsDir ?? path.join(os.homedir(), ".pi", "agent", "sessions");
         this.grokSessionsDir = options.grokSessionsDir ?? path.join(os.homedir(), ".grok", "sessions");
-        this.geminiHome = options.geminiHome ?? path.join(os.homedir(), ".gemini");
     }
     getDiagnostics() {
         return {
@@ -729,28 +727,4 @@ export class ProviderHistoryScanner {
         }
         return deleted;
     }
-    deleteGeminiHistoryFiles(sessionIds) {
-        const ids = new Set(sessionIds.filter((id) => PROVIDER_SESSION_ID_PATTERN.test(id)));
-        if (ids.size === 0 || !existsSync(this.geminiHome))
-            return 0;
-        let deleted = 0;
-        for (const id of ids) {
-            const dbPath = path.join(this.geminiHome, "antigravity-cli", "conversations", `${id}.db`);
-            if (existsSync(dbPath)) {
-                try {
-                    unlinkSync(dbPath);
-                    deleted += 1;
-                }
-                catch { /* already absent */ }
-            }
-            const lockPath = path.join(this.geminiHome, "antigravity-cli", "presence", `${id}.lock`);
-            if (existsSync(lockPath)) {
-                try {
-                    unlinkSync(lockPath);
-                }
-                catch { /* best effort */ }
-            }
-        }
-        return deleted;
-    }
 }

package/dist/render-daemon-client.js

@@ -1,7 +1,7 @@
 import { lstatSync, readFileSync } from "node:fs";
 import net from "node:net";
 import process from "node:process";
-import { rejectPendingRequests, startDaemonHeartbeat, waitForDaemonSocket } from "./daemon-connection.js";
+import { emitToSubscribedListeners, rejectPendingRequests, startDaemonHeartbeat, subscribeWithBufferedEvents, subscribeWithPendingEvent, waitForDaemonSocket } from "./daemon-connection.js";
 import { getErrorMessage } from "./error-utils.js";
 import { appendWindow, PTY_OUTPUT_MAX_SIZE } from "./pty-text-utils.js";
 import { MAX_FRAME_BYTES, RENDER_PROTOCOL_VERSION, encodeRenderFrame, renderPaths, } from "./render-protocol.js";
@@ -71,30 +71,13 @@ class RemoteRenderProcess {
         this.client.fireOperation(this.sessionId, "kill", { sessionId: this.sessionId, signal });
     }
     onData(listener) {
-        this.dataListeners.add(listener);
-        if (this.undeliveredEvents.length > 0) {
-            const pending = this.undeliveredEvents;
+        const pending = this.undeliveredEvents;
+        if (pending.length > 0)
             this.undeliveredEvents = [];
-            queueMicrotask(() => {
-                if (!this.dataListeners.has(listener))
-                    return;
-                for (const event of pending)
-                    listener(event);
-            });
-        }
-        return { dispose: () => this.dataListeners.delete(listener) };
+        return subscribeWithBufferedEvents(this.dataListeners, listener, pending);
     }
     onExit(listener) {
-        this.exitListeners.add(listener);
-        const pending = this.pendingExit;
-        if (pending) {
-            // 退出事件只发生一次，但可能早于 listener 到达；补发语义必须与 data 一致。
-            queueMicrotask(() => {
-                if (this.exitListeners.has(listener))
-                    listener(pending);
-            });
-        }
-        return { dispose: () => this.exitListeners.delete(listener) };
+        return subscribeWithPendingEvent(this.exitListeners, listener, this.pendingExit);
     }
     onResync(listener) {
         this.resyncListeners.add(listener);
@@ -122,21 +105,15 @@ class RemoteRenderProcess {
             listener(state);
     }
     acceptData(event) {
-        if (this.dataListeners.size === 0) {
+        if (!emitToSubscribedListeners(this.dataListeners, event)) {
             this.undeliveredEvents = appendTerminalChunkWindow(this.undeliveredEvents, event);
-            return;
         }
-        this.emitData(event);
     }
     acceptExit(event) {
         this.pendingExit = event;
         for (const listener of Array.from(this.exitListeners))
             listener(event);
     }
-    emitData(event) {
-        for (const listener of Array.from(this.dataListeners))
-            listener(event);
-    }
 }
 /**
  * Render（常驻 PTY 持有者）的 Node 客户端。

package/dist/render-structured-client.js

@@ -1,6 +1,6 @@
 import { lstatSync, readFileSync } from "node:fs";
 import net from "node:net";
-import { rejectPendingRequests, startDaemonHeartbeat, waitForDaemonSocket } from "./daemon-connection.js";
+import { rejectPendingRequests, startDaemonHeartbeat, subscribeWithPendingEvent, waitForDaemonSocket } from "./daemon-connection.js";
 import { getErrorMessage } from "./error-utils.js";
 import { STRUCTURED_RENDER_PROTOCOL_VERSION, decodeRenderFrames, encodeRenderFrame, structuredRenderPaths, } from "./render-structured-protocol.js";
 import { logInfo } from "./runtime-log.js";
@@ -51,12 +51,7 @@ class RemoteRun {
         return { dispose: () => this.streamListeners.delete(listener) };
     }
     onExit(listener) {
-        this.exitListeners.add(listener);
-        const event = this.pendingExit;
-        if (event)
-            queueMicrotask(() => { if (this.exitListeners.has(listener))
-                listener(event); });
-        return { dispose: () => this.exitListeners.delete(listener) };
+        return subscribeWithPendingEvent(this.exitListeners, listener, this.pendingExit);
     }
     acceptStream(event) {
         const last = this.seq[event.stream];

package/dist/retention.js

@@ -2,6 +2,7 @@ import { AI_TEAM_ACTIVE_RUN_STATUSES } from "./ai-team-types.js";
 import { isArchiveBlocked } from "./archive-policy.js";
 import { cleanupWorktreeSync } from "./git-worktree.js";
 import { defaultTaskRetention, taskRetentionWindows } from "./task-retention.js";
+import { parseTimestampMs as timestamp } from "./time-utils.js";
 /** Backward-compatible exports for consumers of the historical default windows. */
 const DEFAULT_RETENTION_WINDOWS = taskRetentionWindows(defaultTaskRetention());
 export const RETENTION_IDLE_MS = DEFAULT_RETENTION_WINDOWS.idleMs;
@@ -17,12 +18,6 @@ function isIdleLivePty(session) {
     return session.status === "running" && !isRetentionBusy(session)
         && ((session.sessionKind ?? "pty") === "pty" || session.runner === "pty");
 }
-function timestamp(value) {
-    if (!value)
-        return null;
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : null;
-}
 /**
  * 任务的「最后一次活动」：卡片自身的 updated_at、容器最后一次被打开的时间，
  * 以及它名下会话的结束/开始时间，取三者里最新的一个。

package/dist/run-command.d.ts

@@ -16,6 +16,11 @@ export interface RunCommandOptions {
     stdio?: SpawnSyncOptionsWithStringEncoding["stdio"];
 }
 export declare function runCommandSync(file: string, args: readonly string[], options?: RunCommandOptions): SpawnSyncReturns<string>;
+/** Foreground operations such as sudo: the terminal owns input (including passwords).
+ * No capture, shell, or timeout: cancellation belongs to the user, and Core drain
+ * may legitimately wait longer than the bounded probe timeout.
+ */
+export declare function runCommandInteractive(file: string, args: readonly string[]): Promise<number>;
 export interface RunCommandResult {
     ok: boolean;
     code: number | null;