@co0ontty/wand 4.83.1 → 4.84.0

package/dist/provider-history-scanner.js

@@ -264,6 +264,9 @@ export class ProviderHistoryScanner {
     codexSessionsDir;
     openCodeDatabasePath;
     qoderProjectsDirs;
+    piSessionsDir;
+    grokSessionsDir;
+    geminiHome;
     claudeIndex = new Map();
     codexIndex = new Map();
     qoderIndex = new Map();
@@ -280,6 +283,9 @@ export class ProviderHistoryScanner {
             path.join(os.homedir(), ".qoder", "projects"),
             path.join(os.homedir(), ".qoder-cn", "projects"),
         ];
+        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 {
@@ -611,11 +617,25 @@ export class ProviderHistoryScanner {
         let database = null;
         try {
             database = new DatabaseSync(this.openCodeDatabasePath);
+            // This is OpenCode's own database, shared with every live `opencode run`. Default
+            // busy_timeout is 0, so one concurrent writer turned a delete into an instant
+            // SQLITE_BUSY that we swallowed as "0 deleted".
+            database.exec("PRAGMA busy_timeout = 5000");
             database.exec("PRAGMA foreign_keys = ON");
+            // `session` has no foreign key to `event_sequence`, so deleting a session row alone
+            // orphans every event row it ever wrote (measured: 425MB across 28 deleted sessions).
+            // Removing the sequence row first cascades to `event` and actually reclaims the space.
+            // The event tables only exist on newer schemas, so their absence must not fail the delete.
+            const hasEventSequence = database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'event_sequence'").get() !== undefined;
+            const dropSequence = hasEventSequence
+                ? database.prepare("DELETE FROM event_sequence WHERE aggregate_id = ?")
+                : null;
             const remove = database.prepare("DELETE FROM session WHERE id = ?");
             let deleted = 0;
-            for (const id of ids)
+            for (const id of ids) {
+                dropSequence?.run(id);
                 deleted += Number(remove.run(id).changes ?? 0);
+            }
             this.invalidate("opencode");
             return deleted;
         }
@@ -647,4 +667,90 @@ export class ProviderHistoryScanner {
         }
         return deleted;
     }
+    deletePiHistoryFiles(sessionIds) {
+        const ids = new Set(sessionIds.filter((id) => PROVIDER_SESSION_ID_PATTERN.test(id)));
+        if (ids.size === 0 || !existsSync(this.piSessionsDir))
+            return 0;
+        let deleted = 0;
+        try {
+            const dirs = readdirSync(this.piSessionsDir, { withFileTypes: true });
+            for (const dir of dirs) {
+                if (!dir.isDirectory())
+                    continue;
+                const projectDir = path.join(this.piSessionsDir, dir.name);
+                try {
+                    const files = readdirSync(projectDir, { withFileTypes: true });
+                    for (const file of files) {
+                        if (!file.isFile() || !file.name.endsWith(".jsonl"))
+                            continue;
+                        const matched = Array.from(ids).some((id) => file.name.endsWith(`_${id}.jsonl`) || file.name === `${id}.jsonl`);
+                        if (matched) {
+                            try {
+                                unlinkSync(path.join(projectDir, file.name));
+                                deleted += 1;
+                            }
+                            catch { /* already absent */ }
+                        }
+                    }
+                }
+                catch { /* ignore per-project read error */ }
+            }
+        }
+        catch {
+            return 0;
+        }
+        return deleted;
+    }
+    deleteGrokHistoryFiles(sessionIds) {
+        const ids = new Set(sessionIds.filter((id) => PROVIDER_SESSION_ID_PATTERN.test(id)));
+        if (ids.size === 0 || !existsSync(this.grokSessionsDir))
+            return 0;
+        let deleted = 0;
+        try {
+            const dirs = readdirSync(this.grokSessionsDir, { withFileTypes: true });
+            for (const dir of dirs) {
+                if (!dir.isDirectory())
+                    continue;
+                const projectDir = path.join(this.grokSessionsDir, dir.name);
+                for (const id of ids) {
+                    const targetDir = path.join(projectDir, id);
+                    if (existsSync(targetDir)) {
+                        try {
+                            rmSync(targetDir, { recursive: true, force: true });
+                            deleted += 1;
+                        }
+                        catch { /* best effort */ }
+                    }
+                }
+            }
+        }
+        catch {
+            return 0;
+        }
+        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/retention.d.ts

@@ -1,29 +1,41 @@
 import type { SessionRegistry } from "./session-registry.js";
 import type { WandStorage } from "./storage.js";
+import { type TaskRetentionSettings } from "./task-retention.js";
+import type { SessionSnapshot } from "./types.js";
 /**
- * 统一保留期策略（会话与看板任务同一套）：
- *   1. 超过 IDLE 没有活动的会话 / 任务 → 自动归档；
- *   2. 归档后经过 ARCHIVED 仍没被恢复 → 自动清理（删除）。
- *
- * 会话的自动归档此前散在两个 runner 里（24h），这里收敛成同一份常量，避免
- * 「会话 24h、任务 7 天」两套口径。运行中的会话/任务永不归档或清理。
+ * 看板任务、会话和已结束的团队运行共用 `taskRetention`。
+ * 没配过时默认空闲 7 天归档，再过 7 天清理。
+ * 结构化会话看运行状态；PTY 只有正在回复或等待确认才跳过，空闲壳不算在处理。
  */
 export declare const RETENTION_IDLE_MS: number;
 export declare const RETENTION_ARCHIVED_MS: number;
 export interface RetentionDeps {
     storage: WandStorage;
     sessions: SessionRegistry;
+    /** 每次扫描读取。传入函数才能在设置保存后立刻用新窗口，而不是启动时的快照。 */
+    taskRetention?: TaskRetentionSettings | (() => TaskRetentionSettings | undefined);
 }
 export interface RetentionResult {
     archivedSessions: number;
     purgedSessions: number;
     archivedTasks: number;
     purgedTasks: number;
+    purgedTeamRuns: number;
 }
+/**
+ * 保留期里的「还在处理」：结构化会话看运行状态；PTY 的 `running` 只表示壳进程还在，
+ * 空闲 zsh 不算。真正挡住清理的是正在回复、或停在权限/确认上。
+ */
+export declare function isRetentionBusy(session: SessionSnapshot): boolean;
 /**
  * 跑一遍保留期清理。返回本轮的实际动作计数，便于日志与测试断言。
  * 纯函数式编排：只依赖 storage / registry，方便在单测里注入固定时间。
  */
 export declare function runRetentionSweep(deps: RetentionDeps, now?: number): RetentionResult;
+/**
+ * 可重复调用的扫描。同一时刻只跑一轮；进行中又被请求时，本轮结束后再跑一轮，
+ * 这样保存设置时不会和定时扫描互相覆盖。
+ */
+export declare function createRetentionSweep(deps: RetentionDeps): () => RetentionResult;
 /** 每小时的保留期扫描；返回清理定时器，调用方负责 clearInterval。 */
-export declare function startRetentionTimer(deps: RetentionDeps, intervalMs?: number): NodeJS.Timeout;
+export declare function startRetentionTimer(deps: RetentionDeps, intervalMs?: number, sweep?: () => RetentionResult): NodeJS.Timeout;

package/dist/retention.js

@@ -1,14 +1,29 @@
 import { cleanupWorktreeSync } from "./git-worktree.js";
+import { taskRetentionWindows } from "./task-retention.js";
 /**
- * 统一保留期策略（会话与看板任务同一套）：
- *   1. 超过 IDLE 没有活动的会话 / 任务 → 自动归档；
- *   2. 归档后经过 ARCHIVED 仍没被恢复 → 自动清理（删除）。
- *
- * 会话的自动归档此前散在两个 runner 里（24h），这里收敛成同一份常量，避免
- * 「会话 24h、任务 7 天」两套口径。运行中的会话/任务永不归档或清理。
+ * 看板任务、会话和已结束的团队运行共用 `taskRetention`。
+ * 没配过时默认空闲 7 天归档，再过 7 天清理。
+ * 结构化会话看运行状态；PTY 只有正在回复或等待确认才跳过，空闲壳不算在处理。
  */
 export const RETENTION_IDLE_MS = 7 * 24 * 60 * 60 * 1000;
 export const RETENTION_ARCHIVED_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * 保留期里的「还在处理」：结构化会话看运行状态；PTY 的 `running` 只表示壳进程还在，
+ * 空闲 zsh 不算。真正挡住清理的是正在回复、或停在权限/确认上。
+ */
+export function isRetentionBusy(session) {
+    if (session.ptyBusy === true || session.structuredState?.inFlight === true)
+        return true;
+    if (session.permissionBlocked || session.pendingEscalation)
+        return true;
+    if ((session.sessionKind ?? "pty") === "pty" || session.runner === "pty")
+        return false;
+    return session.status === "running";
+}
+function isIdleLivePty(session) {
+    return session.status === "running" && !isRetentionBusy(session)
+        && ((session.sessionKind ?? "pty") === "pty" || session.runner === "pty");
+}
 function timestamp(value) {
     if (!value)
         return null;
@@ -40,23 +55,28 @@ function taskLastActivity(storage, task, bound) {
  * 纯函数式编排：只依赖 storage / registry，方便在单测里注入固定时间。
  */
 export function runRetentionSweep(deps, now = Date.now()) {
-    const result = { archivedSessions: 0, purgedSessions: 0, archivedTasks: 0, purgedTasks: 0 };
+    const result = {
+        archivedSessions: 0, purgedSessions: 0, archivedTasks: 0, purgedTasks: 0, purgedTeamRuns: 0,
+    };
+    const taskWindows = taskRetentionWindows(typeof deps.taskRetention === "function" ? deps.taskRetention() : deps.taskRetention);
     const snapshots = deps.sessions.listSlim();
     for (const session of snapshots) {
-        // 运行中的会话既不属于「没动」，也不能被杀掉。
-        if (session.status === "running")
+        // 真正还在处理的会话不能归档或杀掉。空闲 PTY 壳不算。
+        if (isRetentionBusy(session))
             continue;
         if (session.archived) {
+            if (taskWindows.archivedMs === null)
+                continue;
             const archivedAt = timestamp(session.archivedAt);
             if (archivedAt === null) {
-                // 历史归档行没有时间戳：先补上，让 7 天窗口从这一刻起算，而不是立刻删除。
+                // 历史归档行没有时间戳：先补上，让删除窗口从这一刻起算，而不是立刻删除。
                 try {
                     deps.sessions.setArchived(session.id, true);
                 }
                 catch { /* already gone */ }
                 continue;
             }
-            if (now - archivedAt < RETENTION_ARCHIVED_MS)
+            if (now - archivedAt < taskWindows.archivedMs)
                 continue;
             try {
                 deps.sessions.delete(session.id);
@@ -65,9 +85,17 @@ export function runRetentionSweep(deps, now = Date.now()) {
             catch { /* best-effort: a session may disappear between the read and the purge */ }
             continue;
         }
+        if (taskWindows.idleMs === null)
+            continue;
         const reference = timestamp(session.endedAt ?? session.startedAt);
-        if (reference === null || now - reference < RETENTION_IDLE_MS)
+        if (reference === null || now - reference < taskWindows.idleMs)
             continue;
+        if (isIdleLivePty(session)) {
+            try {
+                deps.sessions.stop(session.id);
+            }
+            catch { /* shell may already be gone */ }
+        }
         try {
             deps.sessions.setArchived(session.id, true);
             result.archivedSessions += 1;
@@ -87,9 +115,9 @@ export function runRetentionSweep(deps, now = Date.now()) {
     }
     for (const task of deps.storage.listWandTasks()) {
         const bound = task.workspaceTaskId ? sessionsByTask.get(task.workspaceTaskId) ?? [] : [];
-        const running = bound.some((session) => session.status === "running");
+        const running = bound.some((session) => isRetentionBusy(session));
         if (task.status === "archived") {
-            if (running)
+            if (running || taskWindows.archivedMs === null)
                 continue;
             const archivedAt = timestamp(task.archivedAt);
             if (archivedAt === null) {
@@ -97,7 +125,7 @@ export function runRetentionSweep(deps, now = Date.now()) {
                 deps.storage.updateWandTask(task.id, { status: "archived" });
                 continue;
             }
-            if (now - archivedAt < RETENTION_ARCHIVED_MS)
+            if (now - archivedAt < taskWindows.archivedMs)
                 continue;
             const container = task.workspaceTaskId ? deps.storage.getWorkspaceTask(task.workspaceTaskId) : null;
             if (container?.worktree) {
@@ -110,33 +138,148 @@ export function runRetentionSweep(deps, now = Date.now()) {
             result.purgedTasks += 1;
             continue;
         }
-        if (running)
+        if (running || taskWindows.idleMs === null)
             continue;
         const lastActivity = taskLastActivity(deps.storage, task, bound);
-        if (lastActivity === null || now - lastActivity < RETENTION_IDLE_MS)
+        if (lastActivity === null || now - lastActivity < taskWindows.idleMs)
             continue;
         deps.storage.updateWandTask(task.id, { status: "archived" });
         result.archivedTasks += 1;
     }
+    sweepTeamRuns(deps, taskWindows, snapshots, now, result);
     return result;
 }
-/** 每小时的保留期扫描；返回清理定时器，调用方负责 clearInterval。 */
-export function startRetentionTimer(deps, intervalMs = 60 * 60 * 1000) {
-    const sweep = () => {
-        try {
-            const result = runRetentionSweep(deps);
-            const acted = result.archivedSessions + result.purgedSessions + result.archivedTasks + result.purgedTasks;
-            if (acted > 0) {
-                console.log(`[retention] archived sessions=${result.archivedSessions} tasks=${result.archivedTasks}; `
-                    + `purged sessions=${result.purgedSessions} tasks=${result.purgedTasks}`);
+function sweepTeamRuns(deps, windows, snapshots, now, result) {
+    const sessionById = new Map(snapshots.map((session) => [session.id, session]));
+    for (const run of deps.storage.listAiTeamRuns()) {
+        if (run.status === "running")
+            continue;
+        const linked = teamRunSessionIds(deps.storage, run.id, run.chatSessionId);
+        if (linked.some((id) => {
+            const session = sessionById.get(id);
+            return session ? isRetentionBusy(session) : false;
+        }))
+            continue;
+        const activity = teamRunActivity(run.updatedAt, linked, sessionById);
+        if (activity === null)
+            continue;
+        if (windows.archivedMs !== null && now - activity >= windows.archivedMs) {
+            for (const id of linked) {
+                const session = sessionById.get(id);
+                if (!session || isRetentionBusy(session))
+                    continue;
+                if (isIdleLivePty(session)) {
+                    try {
+                        deps.sessions.stop(id);
+                    }
+                    catch { /* already gone */ }
+                }
+                try {
+                    deps.sessions.delete(id);
+                    result.purgedSessions += 1;
+                    sessionById.delete(id);
+                }
+                catch { /* already gone */ }
             }
+            deps.storage.deleteAiTeamRun(run.id);
+            result.purgedTeamRuns += 1;
+            continue;
+        }
+        if (windows.idleMs === null || now - activity < windows.idleMs)
+            continue;
+        for (const id of linked) {
+            const session = sessionById.get(id);
+            if (!session || session.archived || isRetentionBusy(session))
+                continue;
+            if (isIdleLivePty(session)) {
+                try {
+                    deps.sessions.stop(id);
+                }
+                catch { /* already gone */ }
+            }
+            try {
+                deps.sessions.setArchived(id, true);
+                session.archived = true;
+                result.archivedSessions += 1;
+            }
+            catch { /* best-effort */ }
+        }
+    }
+}
+function teamRunSessionIds(storage, runId, chatSessionId) {
+    const ids = new Set();
+    if (chatSessionId)
+        ids.add(chatSessionId);
+    for (const step of storage.listAiTeamSteps(runId)) {
+        if (step.sessionId)
+            ids.add(step.sessionId);
+    }
+    return [...ids];
+}
+function teamRunActivity(updatedAt, sessionIds, sessionById) {
+    const times = [];
+    const updated = timestamp(updatedAt);
+    if (updated !== null)
+        times.push(updated);
+    for (const id of sessionIds) {
+        const session = sessionById.get(id);
+        const reference = timestamp(session?.endedAt ?? session?.startedAt);
+        if (reference !== null)
+            times.push(reference);
+    }
+    return times.length > 0 ? Math.max(...times) : null;
+}
+function logRetentionSweep(result) {
+    const acted = result.archivedSessions + result.purgedSessions + result.archivedTasks + result.purgedTasks + result.purgedTeamRuns;
+    if (acted > 0) {
+        console.log(`[retention] archived sessions=${result.archivedSessions} tasks=${result.archivedTasks}; `
+            + `purged sessions=${result.purgedSessions} tasks=${result.purgedTasks} teamRuns=${result.purgedTeamRuns}`);
+    }
+}
+/**
+ * 可重复调用的扫描。同一时刻只跑一轮；进行中又被请求时，本轮结束后再跑一轮，
+ * 这样保存设置时不会和定时扫描互相覆盖。
+ */
+export function createRetentionSweep(deps) {
+    const empty = {
+        archivedSessions: 0, purgedSessions: 0, archivedTasks: 0, purgedTasks: 0, purgedTeamRuns: 0,
+    };
+    let running = false;
+    let again = false;
+    let last = empty;
+    return () => {
+        if (running) {
+            again = true;
+            return last;
+        }
+        running = true;
+        try {
+            do {
+                again = false;
+                last = runRetentionSweep(deps);
+                logRetentionSweep(last);
+            } while (again);
+            return last;
         }
         catch (error) {
             console.error(`[retention] sweep failed: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+        finally {
+            running = false;
+        }
+    };
+}
+/** 每小时的保留期扫描；返回清理定时器，调用方负责 clearInterval。 */
+export function startRetentionTimer(deps, intervalMs = 60 * 60 * 1000, sweep = createRetentionSweep(deps)) {
+    const run = () => {
+        try {
+            sweep();
         }
+        catch { /* createRetentionSweep 已记录 */ }
     };
-    sweep();
-    const timer = setInterval(sweep, intervalMs);
+    run();
+    const timer = setInterval(run, intervalMs);
     timer.unref?.();
     return timer;
 }

package/dist/server-ai-team-routes.js

@@ -290,10 +290,14 @@ export function registerAiTeamRoutes(app, deps) {
             sendTeamError(res, error);
         }
     });
-    /** 运行中步骤的 live 文本（§4.9）：Web 走 ai-team-step-live 推送，移动端轻量轮询这个端点。 */
+    /**
+     * 运行中步骤的 live 文本（§4.9.1）：Web 走 ai-team-step-live 推送，移动端轻量轮询这个端点。
+     * 除步骤快照外还回 run 级活动时间（startedAt / lastActivityAt / observedAt），轮询端不必
+     * 再拉一次 detail 才知道「还在跑、只是这一轮安静」。
+     */
     app.get("/api/ai-team-runs/:id/live", (req, res) => {
         try {
-            res.json({ runId: req.params.id, steps: runner.live(req.params.id) });
+            res.json(runner.liveSnapshot(req.params.id));
         }
         catch (error) {
             sendTeamError(res, error);

package/dist/server-conversation-routes.d.ts

@@ -0,0 +1,5 @@
+import type { Express } from "express";
+import type { ConversationService } from "./conversation-service.js";
+export declare function registerConversationRoutes(app: Express, service: ConversationService): void;
+/** Compatibility relay inputs are ordinary talk; never infer the newest task or approve a short phrase. */
+export declare function forwardConversationRelay(service: ConversationService, sessionId: string, input: string): Promise<void>;

package/dist/server-conversation-routes.js

@@ -0,0 +1,91 @@
+import { randomUUID } from "node:crypto";
+import { AiTeamConflictError } from "./ai-team-runner.js";
+import { asyncRoute } from "./express-async.js";
+import { bodyObject, sendRouteError, text } from "./server-request.js";
+function targetOf(value) {
+    if (value === null || value === undefined)
+        return null;
+    const body = bodyObject(value);
+    if (!text(body.taskId) || !text(body.runId))
+        throw new Error("发送目标需要明确 taskId 和 runId。");
+    return { taskId: text(body.taskId), runId: text(body.runId) };
+}
+function result(res, receipt) {
+    if (receipt.state === "rejected")
+        res.status(400).json({ error: receipt.error ?? "请求未接受。", receipt });
+    else
+        res.status(202).json(receipt);
+}
+export function registerConversationRoutes(app, service) {
+    app.get("/api/conversations", (req, res) => res.json({ conversations: service.list() }));
+    app.patch("/api/conversations/:id/list-state", (req, res) => {
+        try {
+            const body = bodyObject(req.body);
+            if ((body.pinned !== undefined && typeof body.pinned !== "boolean") || (body.dissolved !== undefined && typeof body.dissolved !== "boolean")
+                || (body.pinned === undefined && body.dissolved === undefined))
+                throw new Error("请提供有效的置顶或列表显示状态。");
+            res.json(service.updateListState(req.params.id, { pinned: body.pinned, dissolved: body.dissolved }));
+        }
+        catch (error) {
+            sendRouteError(res, error, "对话列表更新失败。", 400);
+        }
+    });
+    app.delete("/api/conversations/:id", asyncRoute(async (req, res) => {
+        try {
+            await service.remove(req.params.id);
+            res.json({ ok: true });
+        }
+        catch (error) {
+            sendRouteError(res, error, "删除对话失败。", error instanceof AiTeamConflictError ? 409 : 400);
+        }
+    }));
+    app.get("/api/conversations/requests/:requestId", (req, res) => {
+        const receipt = service.receipt(req.params.requestId);
+        if (!receipt)
+            res.status(404).json({ error: "未找到回执；不能据此断言请求未接受。" });
+        else
+            res.json(receipt);
+    });
+    app.get("/api/conversations/:id", (req, res) => {
+        try {
+            res.json(service.detail(req.params.id));
+        }
+        catch (error) {
+            sendRouteError(res, error, "对话读取失败。", 404);
+        }
+    });
+    const post = (path, operation) => {
+        app.post(path, asyncRoute(async (req, res) => {
+            try {
+                result(res, await operation(req.params.id ?? "", bodyObject(req.body)));
+            }
+            catch (error) {
+                sendRouteError(res, error, "对话操作失败。", error instanceof AiTeamConflictError ? 409 : 400);
+            }
+        }));
+    };
+    post("/api/conversations", (_id, body) => service.createGroup(text(body.requestId), bodyObject(body.group)));
+    post("/api/conversations/:id/invitations", (id, body) => service.invite(id, text(body.requestId), Number(body.memberVersion), bodyObject(body.group)));
+    post("/api/conversations/:id/channel", (id, body) => service.prepare(id, text(body.requestId), text(body.cwd) || undefined));
+    post("/api/conversations/:id/messages", (id, body) => service.send(id, text(body.requestId), text(body.input), targetOf(body.target), text(body.cwd) || undefined));
+    post("/api/conversations/:id/tasks", (id, body) => service.dispatch(id, text(body.requestId), {
+        title: text(body.title), description: text(body.description), workspaceId: text(body.workspaceId), cwd: text(body.cwd) || undefined,
+        memberVersion: body.memberVersion === undefined ? undefined : Number(body.memberVersion),
+        continueTaskId: text(body.continueTaskId) || undefined,
+    }));
+    post("/api/conversations/:id/actions", (id, body) => {
+        const target = targetOf(body.target);
+        if (!target)
+            throw new Error("运行操作需要明确任务与轮次。");
+        return service.act(id, text(body.requestId), target, text(body.action), body.extraSteps === undefined ? undefined : Number(body.extraSteps));
+    });
+}
+/** Compatibility relay inputs are ordinary talk; never infer the newest task or approve a short phrase. */
+export async function forwardConversationRelay(service, sessionId, input) {
+    const group = service.list().find((item) => item.sessionId === sessionId);
+    if (!group)
+        throw new Error("群实例不存在，请从对话列表核对。");
+    const receipt = await service.send(group.id, randomUUID(), input, null, undefined, false);
+    if (receipt.error)
+        throw new Error(receipt.error);
+}

package/dist/server-employee-routes.d.ts

@@ -19,4 +19,6 @@ export declare function registerSiliconEmployeeRoutes(app: Express, deps: {
     config?: WandConfig;
     /** 测试注入点：默认按系统 AI 配置真实调用模型。 */
     generateDraft?: (request: EmployeeDraftRequest) => Promise<SiliconEmployeeDraft>;
+    /** 测试注入点：CLI 可用性探测。 */
+    isProviderAvailable?: (agent: WandTaskAgent) => boolean;
 }): void;