@co0ontty/wand 4.97.0 → 4.98.0

package/dist/storage/tasks-repository.d.ts

@@ -19,6 +19,28 @@ export declare class TaskRepository {
     listWandTasks(workspaceId?: string | null): WandTask[];
     mapWandTaskRow(row: Record<string, unknown>): WandTask;
     listWandTaskComments(taskId: string): WandTaskComment[];
+    getWandTaskComment(id: string): WandTaskComment | null;
+    findTaskCommentRequest(taskId: string, requestId: string): {
+        comment: WandTaskComment;
+        signature: string;
+    } | null;
+    /** Atomically persist both the visible comment and the one-shot dispatch intent before any side effect. */
+    createTaskCommentIntent(input: {
+        taskId: string;
+        requestId: string;
+        signature: string;
+        body: string;
+        instruction: string;
+        sourceCommentId: string | null;
+        employeeId: string | null;
+        employeeName: string | null;
+        taskVersion: string;
+    }): WandTaskComment;
+    updateTaskCommentDispatch(id: string, state: "pending" | "accepted" | "failed" | "unknown", sessionId: string | null, error?: string | null): void;
+    /** Read-only recovery of the create/bind crash gap, by a server-generated correlation ID, never message text. */
+    findTaskCommentExecutionSessionId(commentId: string, employeeId: string): string | null;
+    /** Event-owned facts, including stop outcomes which structured sessions intentionally represent as idle. */
+    recordTaskCommentSessionEvent(event: import("../types.js").ProcessEvent): void;
     getWandTask(id: string): WandTask | null;
     getWandTaskByWorkspaceTaskId(workspaceTaskId: string): WandTask | null;
     insertWandTask(input: CreateWandTaskInput, createdAt?: string): WandTask;

package/dist/storage/tasks-repository.js

@@ -99,9 +99,58 @@ export class TaskRepository {
         };
     }
     listWandTaskComments(taskId) {
-        const rows = this.db.prepare(`SELECT id, task_id, author_name, body, created_at
-      FROM wand_task_comments WHERE task_id = ? ORDER BY rowid DESC LIMIT 50`).all(taskId);
-        return rows.reverse().map(row => ({ id: row.id, taskId: row.task_id, authorName: row.author_name, body: row.body, createdAt: row.created_at }));
+        const rows = this.db.prepare(`SELECT id FROM wand_task_comments WHERE task_id = ? ORDER BY rowid DESC LIMIT 50`).all(taskId);
+        return rows.reverse().map(row => this.getWandTaskComment(row.id));
+    }
+    getWandTaskComment(id) {
+        const row = this.db.prepare(`SELECT c.*, d.request_id, d.source_comment_id, d.employee_id, d.employee_name,
+      d.instruction, d.task_version, d.state, d.session_id, d.error, d.execution_status FROM wand_task_comments c
+      LEFT JOIN wand_task_comment_dispatches d ON d.comment_id = c.id WHERE c.id = ?`).get(id);
+        if (!row)
+            return null;
+        return { id: row.id, taskId: row.task_id, authorName: row.author_name, body: row.body, createdAt: row.created_at,
+            ...(row.request_id ? { requestId: row.request_id, sourceCommentId: row.source_comment_id, instruction: row.instruction, taskVersion: row.task_version,
+                dispatch: row.employee_id ? { employeeId: row.employee_id, employeeName: row.employee_name,
+                    state: row.state, sessionId: row.session_id, error: row.error, ...(row.execution_status ? { status: row.execution_status } : {}) } : null } : {}) };
+    }
+    findTaskCommentRequest(taskId, requestId) {
+        const row = this.db.prepare(`SELECT comment_id, signature FROM wand_task_comment_dispatches WHERE task_id = ? AND request_id = ?`)
+            .get(taskId, requestId);
+        return row ? { comment: this.getWandTaskComment(row.comment_id), signature: row.signature } : null;
+    }
+    /** Atomically persist both the visible comment and the one-shot dispatch intent before any side effect. */
+    createTaskCommentIntent(input) {
+        return this.s.transaction(() => {
+            const id = crypto.randomUUID();
+            this.db.prepare(`INSERT INTO wand_task_comments(id, task_id, author_name, body, created_at) VALUES (?, ?, ?, ?, ?)`)
+                .run(id, input.taskId, "用户", input.body, nowIso());
+            this.db.prepare(`INSERT INTO wand_task_comment_dispatches(comment_id, task_id, request_id, signature, source_comment_id,
+        employee_id, employee_name, instruction, task_version, state) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(id, input.taskId, input.requestId, input.signature, input.sourceCommentId, input.employeeId, input.employeeName, input.instruction, input.taskVersion, input.employeeId ? "pending" : "accepted");
+            return this.getWandTaskComment(id);
+        });
+    }
+    updateTaskCommentDispatch(id, state, sessionId, error = null) {
+        this.db.prepare(`UPDATE wand_task_comment_dispatches SET state = ?, session_id = COALESCE(?, session_id), error = ? WHERE comment_id = ?`)
+            .run(state, sessionId, error, id);
+    }
+    /** Read-only recovery of the create/bind crash gap, by a server-generated correlation ID, never message text. */
+    findTaskCommentExecutionSessionId(commentId, employeeId) {
+        const rows = this.db.prepare("SELECT id FROM command_sessions WHERE automation_id = ? LIMIT 2")
+            .all(`wand-task-comment:${commentId}`);
+        return rows.length === 1 && this.s.getSessionSlim(rows[0].id)?.employeeId === employeeId ? rows[0].id : null;
+    }
+    /** Event-owned facts, including stop outcomes which structured sessions intentionally represent as idle. */
+    recordTaskCommentSessionEvent(event) {
+        const data = event.data;
+        if (!data || typeof data !== "object")
+            return;
+        const status = data.turnOutcome === "stopped" ? "stopped" : data.structuredState?.inFlight ? "running"
+            : data.structuredState?.lastError ? "failed" : data.status;
+        if (!status)
+            return;
+        this.db.prepare("UPDATE wand_task_comment_dispatches SET execution_status = ? WHERE session_id = ?")
+            .run(status, event.sessionId);
     }
     getWandTask(id) {
         const row = this.db.prepare(`SELECT ${WAND_TASK_FIELDS} FROM wand_tasks WHERE id = ?`)

package/dist/storage/workspaces-repository.d.ts

@@ -37,6 +37,7 @@ export declare class WorkspaceRepository {
     /** Normal workspace counts exclude archived sessions and sessions in archived tasks. */
     countSessionsByWorkspace(options?: {
         includeArchived?: boolean;
+        excludeSystemAiCalls?: boolean;
     }): Map<string, number>;
     /** Count user-initiated CLI launches (one per session), including archived sessions. */
     countInteractiveSessionsByProvider(): Record<SessionProvider, number>;

package/dist/storage/workspaces-repository.js

@@ -8,6 +8,7 @@ import { isUnnamedWorkspaceTaskName } from "../wand-task-sync.js";
 import { ensureWorkspaceForCwd } from "../workspace-binding.js";
 import { parseWorktreeInfo, sessionSelectFields, mapWorkspaceRow, mapWorkspaceTaskRow, mapSessionCore, sessionRowQuery } from "./mappers.js";
 import { WAND_TASK_FIELDS, WORKSPACE_TASK_PROJECTION } from "./internal.js";
+import { SYSTEM_AI_CALL_PREFIX } from "../system-ai-call.js";
 /** Workspace storage: one domain of the WandStorage facade. Shares the connection and the facade's transaction. */
 export class WorkspaceRepository {
     db;
@@ -173,8 +174,9 @@ export class WorkspaceRepository {
              SELECT status FROM wand_tasks WHERE workspace_task_id = session.workspace_task_id
              ORDER BY updated_at DESC, rowid DESC LIMIT 1
            ), '') <> 'archived'))
+           AND (? = 0 OR COALESCE(session.automation_id, '') NOT GLOB ?)
          GROUP BY session.workspace_id`)
-            .all(options.includeArchived === true ? 1 : 0);
+            .all(options.includeArchived === true ? 1 : 0, options.excludeSystemAiCalls === true ? 1 : 0, `${SYSTEM_AI_CALL_PREFIX}*`);
         return new Map(rows.map((row) => [row.id, Number(row.n) || 0]));
     }
     /** Count user-initiated CLI launches (one per session), including archived sessions. */

package/dist/storage-cleanup.d.ts

@@ -11,7 +11,18 @@ export interface CleanupReport {
     allocatedBytes: number;
     skipped: number;
     issues: string[];
-    byKind: Partial<Record<TempKind | "upload" | "diagnostic-log", number>>;
+    byKind: Partial<Record<TempKind | "upload" | "diagnostic-log" | "distribution-package" | "native-run" | "migration-snapshot", number>>;
+}
+/** pi-native 回收结果（与 PiTmuxHost.collectGarbage 的返回一致）。 */
+export interface PiNativeGcReport {
+    removedSlots: number;
+    removedTurns: number;
+    freedBytes: number;
+}
+/** 分发包清理结果（由 DistributionManager 提供，只保留最新一套产物）。 */
+export interface DistributionPruneResult {
+    deleted: string[];
+    freedBytes: number;
 }
 interface CleanupOptions {
     roots: string[];
@@ -23,6 +34,24 @@ interface CleanupOptions {
     uploads?: Pick<UploadRepository, "listManagedUploads" | "managedUploadReferenced" | "observeManagedUpload" | "forgetManagedUpload">;
     uploadsActive?: () => boolean;
     onUploadRemoved?: (cwd: string) => void;
+    /**
+     * 清理分发目录里的历史构建包（Android APK / macOS zip+dmg / iOS IPA）。
+     * 只在 apply 时调用：预览不能删文件。保留规则由 DistributionManager 统一持有，
+     * 这里不重复一份「哪个是最新」的判断。
+     */
+    pruneDistributionArtifacts?: () => Promise<DistributionPruneResult>;
+    /**
+     * 回收 pi-native 下废弃的回合目录。同样只在 apply 时调用，失败不阻断其他回收。
+     */
+    collectNativeArtifacts?: () => PiNativeGcReport | null;
+    /**
+     * 修剪迁移前 SQLite 快照（旧版本遗留的无上限堆积）。迁移成功路径已经在
+     * storage-schema 里修剪一次，这里只是把历史遗留的一起收掉。
+     */
+    pruneMigrationSnapshots?: () => {
+        deleted: string[];
+        freedBytes: number;
+    };
 }
 /** Runtime-only, explicit ownership. User history, downloads and rollback inputs are never candidates. */
 export declare class StorageCleanup {
@@ -44,7 +73,13 @@ export declare class StorageCleanup {
     stop(): Promise<void>;
     run(apply?: boolean): Promise<CleanupReport>;
     private sweep;
+    /**
+     * 历史构建包回收。这是唯一需要把「版本比较」交给外部的清理：哪个包是「最新」
+     * 必须和更新检查同一个答案，所以保留规则住在 DistributionManager，这里只调用。
+     * 失败不阻断其他回收。
+     */
+    private sweepDistributionArtifacts;
     private sweepTemporary;
 }
-export declare function createStorageCleanup(configDir: string, options?: Pick<CleanupOptions, "uploads" | "uploadsActive" | "onUploadRemoved">): StorageCleanup;
+export declare function createStorageCleanup(configDir: string, options?: Pick<CleanupOptions, "uploads" | "uploadsActive" | "onUploadRemoved" | "pruneDistributionArtifacts" | "collectNativeArtifacts" | "pruneMigrationSnapshots">): StorageCleanup;
 export {};

package/dist/storage-cleanup.js

@@ -212,8 +212,68 @@ export class StorageCleanup {
                 report.skipped++;
             }
         }
+        await this.sweepDistributionArtifacts(apply, report);
         return report;
     }
+    /**
+     * 历史构建包回收。这是唯一需要把「版本比较」交给外部的清理：哪个包是「最新」
+     * 必须和更新检查同一个答案，所以保留规则住在 DistributionManager，这里只调用。
+     * 失败不阻断其他回收。
+     */
+    async sweepDistributionArtifacts(apply, report) {
+        if (!apply || this.stopped)
+            return;
+        const detail = [];
+        if (this.options.pruneDistributionArtifacts) {
+            try {
+                const pruned = await this.options.pruneDistributionArtifacts();
+                if (pruned.deleted.length > 0) {
+                    report.removed += pruned.deleted.length;
+                    report.logicalBytes += pruned.freedBytes;
+                    report.byKind["distribution-package"] = pruned.deleted.length;
+                    detail.push(`分发构建包 ${pruned.deleted.length} 个（${(pruned.freedBytes / 1024 / 1024).toFixed(1)} MB）：${pruned.deleted.join(", ")}`);
+                }
+            }
+            catch {
+                report.issues.push("Distribution package cleanup failed; packages preserved.");
+            }
+        }
+        if (this.options.collectNativeArtifacts) {
+            try {
+                const native = this.options.collectNativeArtifacts();
+                const removed = (native?.removedSlots ?? 0) + (native?.removedTurns ?? 0);
+                if (native && removed > 0) {
+                    report.removed += removed;
+                    report.logicalBytes += native.freedBytes;
+                    report.byKind["native-run"] = removed;
+                    detail.push(`Pi 原生产物 ${removed} 个（${(native.freedBytes / 1024 / 1024).toFixed(1)} MB）`
+                        + `：slot ${native.removedSlots} 个 / turn ${native.removedTurns} 个`);
+                }
+            }
+            catch {
+                report.issues.push("Native run artifact cleanup failed; artifacts preserved.");
+            }
+        }
+        if (this.options.pruneMigrationSnapshots) {
+            try {
+                const snapshots = this.options.pruneMigrationSnapshots();
+                if (snapshots.deleted.length > 0) {
+                    report.removed += snapshots.deleted.length;
+                    report.logicalBytes += snapshots.freedBytes;
+                    report.byKind["migration-snapshot"] = snapshots.deleted.length;
+                    detail.push(`迁移快照 ${snapshots.deleted.length} 份（${(snapshots.freedBytes / 1024 / 1024).toFixed(1)} MB）：${snapshots.deleted.join(", ")}`);
+                }
+            }
+            catch {
+                report.issues.push("Migration snapshot cleanup failed; snapshots preserved.");
+            }
+        }
+        // 后台删除必须留痕迹：这些路径不是用户主动触发，没有日志就无法事后追溯删了什么。
+        if (detail.length > 0)
+            process.stdout.write(`[storage-cleanup] 已回收 ${detail.join("；")}\n`);
+        for (const issue of report.issues)
+            process.stdout.write(`[storage-cleanup] ${issue}\n`);
+    }
     async sweepTemporary(apply) {
         const now = (this.options.now ?? Date.now)();
         const cutoff = now - STORAGE_CLEANUP_RETENTION_DAYS * DAY;
@@ -266,7 +326,7 @@ export class StorageCleanup {
                             report.skipped++;
                             continue;
                         }
-                        const stat = await stats(directory, (await lstat(root)).dev, lease.kind === "test-run" || lease.kind === "speech-setup");
+                        const stat = await stats(directory, (await lstat(root)).dev, lease.kind === "test-run");
                         if (stat.latest >= cutoff) {
                             report.skipped++;
                             continue;
@@ -311,7 +371,7 @@ export class StorageCleanup {
                     report.skipped++;
                     continue;
                 }
-                const latest = await stats(candidate.directory, candidate.stat.dev, lease.kind === "test-run" || lease.kind === "speech-setup");
+                const latest = await stats(candidate.directory, candidate.stat.dev, lease.kind === "test-run");
                 if (latest.ino !== candidate.stat.ino || latest.latest >= cutoff) {
                     report.skipped++;
                     continue;

package/dist/storage-schema.js

@@ -3,6 +3,7 @@ import { chmodSync, existsSync, mkdirSync } from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { STORAGE_MIGRATIONS } from "./storage/migrations.js";
+import { pruneMigrationBackups } from "./migration-backup-retention.js";
 import { SCHEDULED_CLAIM_DATE_SQL } from "./storage-schedules.js";
 /** Additive schema only. Domain migrations and transactions remain owned by WandStorage. */
 const INIT_SQL = `
@@ -733,6 +734,14 @@ export function migrateStorageSchema(db, options) {
             throw new Error(`[wand] storage migration v${migration.version} (${migration.name}) failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
         }
     }
+    // 只有全部迁移提交成功后才修剪旧快照：失败时回滚点必须完整保留。
+    // 本次刚生成的这一份始终保留，修剪失败不影响迁移结果。
+    if (backupPath) {
+        try {
+            pruneMigrationBackups(options.dbPath, { keepPath: backupPath });
+        }
+        catch { /* best-effort */ }
+    }
     return { fromVersion, toVersion: readStorageSchemaVersion(db), backupPath, newerSchema: false };
 }
 /** Open (creating if needed) and migrate a database file. Owner-only permissions. */

package/dist/structured-claude-adapter.js

@@ -151,7 +151,11 @@ export class ClaudeCliRunner {
             file: "claude",
             args,
             cwd: context.session.cwd,
-            env: context.env,
+            // Claude print mode otherwise kills live background agents ten minutes
+            // after the parent's last turn, even while children are making progress,
+            // then exits 0. Wand owns cancellation; keep the CLI alive until its work
+            // settles instead of imposing that independent parent-idle deadline.
+            env: { ...context.env, CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS: "0" },
             stdinData: context.prompt,
             observer,
             execHost: this.execHost,

package/dist/structured-claude-protocol.d.ts

@@ -20,7 +20,7 @@ interface ClaudeCliTurnState extends StructuredRunnerTurnState {
 export declare class ClaudeCliProtocolReducer {
     readonly state: ClaudeCliTurnState;
     askUserQuestionDetected: boolean;
-    /** result 事件带 is_error 时的说明（如「API Error: 503 …」），作为这一轮的主错误。 */
+    /** 原生 result 错误或系统强停子代理的说明，作为这一轮的主错误。 */
     errorText: string | null;
     /** 协议里出现过带 is_error 的 result 事件；没有本轮助手内容时才是可降级的执行前拒绝。 */
     errorResultObserved: boolean;

package/dist/structured-claude-protocol.js

@@ -121,7 +121,7 @@ export function extractClaudeAssistantMessage(message) {
 export class ClaudeCliProtocolReducer {
     state;
     askUserQuestionDetected = false;
-    /** result 事件带 is_error 时的说明（如「API Error: 503 …」），作为这一轮的主错误。 */
+    /** 原生 result 错误或系统强停子代理的说明，作为这一轮的主错误。 */
     errorText = null;
     /** 协议里出现过带 is_error 的 result 事件；没有本轮助手内容时才是可降级的执行前拒绝。 */
     errorResultObserved = false;
@@ -269,6 +269,17 @@ export class ClaudeCliProtocolReducer {
                 if (detail)
                     this.errorText = detail;
             }
+            else if (!this.qoder) {
+                // Claude 2.1.296 can report success / exit 0 after its background-wait
+                // ceiling has killed children. Use the native execution facts, never
+                // the parent's prose or stderr keywords, and never classify this as an
+                // upstream rejection that would authorize replay of already-run work.
+                const stats = event.subagent_stats;
+                const killed = stats?.killed?.system;
+                if (typeof killed === "number" && Number.isSafeInteger(killed) && killed > 0 && !this.errorText) {
+                    this.errorText = `Claude Code 被系统停止了 ${killed} 个子代理，任务未完整完成；请检查已有改动后再续接，不要自动重跑。`;
+                }
+            }
             this.state.model = extractClaudeModelName(event.modelUsage && typeof event.modelUsage === "object"
                 ? event.modelUsage
                 : undefined) ?? this.state.model;

package/dist/structured-runner.d.ts

@@ -49,6 +49,8 @@ export interface StructuredRunnerContext {
     env: NodeJS.ProcessEnv;
     /** Execution-only group boundary; never persisted/projected to session DTOs. */
     modelGroupModels?: readonly string[];
+    /** Core-only: synchronously persist one queued user turn and the preceding assistant segment. */
+    takeSteering?(state: StructuredRunnerTurnState): string | null;
 }
 export interface StructuredRunnerObserver {
     isActive(): boolean;

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

@@ -10,6 +10,7 @@ import type { CoreStatus } from "./core-status-cli.js";
 import { type EngineResolution } from "./harness-engine.js";
 import { type PiSessionSettings } from "./pi-session-settings.js";
 import { type DecisionRuntimeAccess } from "./decision-runner.js";
+import { type PiNativeGcReport } from "./pi-tmux-host.js";
 import { type StructuredExecHost } from "./structured-exec-host.js";
 import type { StructuredRunnerAdapter } from "./structured-runner.js";
 export { structuredQuietStatusData, getLastSubmittedStructuredInput, isDuplicateStructuredQueueInput } from "./structured-session-manager-replay.js";
@@ -177,6 +178,15 @@ export declare class StructuredSessionManager {
     private saveAuthoritativeSession;
     private checkpointSessionMessages;
     list(): SessionSnapshot[];
+    /**
+     * 回收 Pi 原生执行宿主下的废弃产物（旧 turn 目录与无主 slot）。
+     * 只有真在跑原生 tmux 时才有意义，否则返回 null 表示本次未执行。
+     */
+    collectNativeGarbage(options: {
+        liveSessionIds: ReadonlySet<string>;
+        retentionMs: number;
+        now?: number;
+    }): PiNativeGcReport | null;
     /** Return lightweight snapshots for the session list (no output/messages). */
     listSlim(): SessionSnapshot[];
     get(id: string): SessionSnapshot | null;
@@ -240,6 +250,7 @@ export declare class StructuredSessionManager {
     private settleAutoAssignForSend;
     /** Runs one turn through the runner that owns the session's provider (and, for Pi, its engine). */
     private runProviderTurn;
+    private usesCoreEngine;
     private runPiTurn;
     /**
      * A turn threw before the runner reported its own outcome. Re-throws errors that
@@ -255,7 +266,7 @@ export declare class StructuredSessionManager {
      * 期间改"已经被 flushNextQueuedMessage 拿走的队首"，但本方法只动 queue 数组
      * 本身，flushNext 在另一段时序里读 sessions.get(...) 当前快照，已经天然安全。
      */
-    reorderQueuedMessages(sessionId: string, order: number[]): SessionSnapshot;
+    reorderQueuedMessages(sessionId: string, order: number[], expectedQueue?: readonly string[]): SessionSnapshot;
     /** Edit only the pending item still identified by both index and original text. */
     editQueuedMessage(sessionId: string, index: number, expectedText: string, text: string): SessionSnapshot;
     /** Remove a single queued message only while index and text still identify the same item. */
@@ -266,8 +277,9 @@ export declare class StructuredSessionManager {
      * queue entry remains available for the automatic flush path.
      */
     promoteQueuedMessage(sessionId: string, index: number, expectedText?: string, idempotencyKey?: string): Promise<SessionSnapshot>;
+    private assertExpectedQueue;
     /** Clear all queued messages. No-op when queue is already empty. */
-    clearQueuedMessages(sessionId: string): SessionSnapshot;
+    clearQueuedMessages(sessionId: string, expectedQueue?: readonly string[]): SessionSnapshot;
     /** 仅空白独立对话能改目录：不建替代会话、不迁移任务/worktree 或已接受的输入。 */
     setSessionDirectory(sessionId: string, cwd: string): SessionSnapshot;
     /** 空白对话原位换执行工具；引擎也是工具身份，不跨工具搬历史或能力设置。 */

package/dist/structured-session-manager.js

@@ -1039,6 +1039,16 @@ export class StructuredSessionManager {
             .map(withSummary)
             .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
     }
+    /**
+     * 回收 Pi 原生执行宿主下的废弃产物（旧 turn 目录与无主 slot）。
+     * 只有真在跑原生 tmux 时才有意义，否则返回 null 表示本次未执行。
+     */
+    collectNativeGarbage(options) {
+        const host = this.execHost;
+        if (!(host instanceof PiTmuxHost))
+            return null;
+        return host.collectGarbage(options);
+    }
     /** Return lightweight snapshots for the session list (no output/messages). */
     listSlim() {
         return Array.from(this.sessions.values())
@@ -1399,7 +1409,10 @@ export class StructuredSessionManager {
             return await this.relayUserMessage(id, prompt, relay);
         if (opts?.idempotencyKey)
             this.claimIdempotencyKey(id, opts.idempotencyKey);
-        // Pi 主功能现在固定走 CLI；core SDK 重启 drain 不影响 CLI 会话入场。
+        // The drain owns Core admission, not CLI admission. Check before any
+        // asynchronous selection/topic work; accepted Core inputs remain durable.
+        if (this.coreRestartDrains > 0 && this.usesCoreEngine(session))
+            return this.enqueueInput(session, prompt);
         this.maybeGenerateSessionTopic(id, prompt);
         // 「智能分配」结算窗口：还没有 runner 归属，新输入先排队，不能另起一轮。
         if (this.autoAssignPending.has(id))
@@ -1412,8 +1425,20 @@ export class StructuredSessionManager {
             const assigned = await this.settleAutoAssignForSend(id, session, prompt);
             if ("result" in assigned)
                 return assigned.result;
-            session = assigned.session;
-        }
+            session = this.requireSession(id);
+            // Selection yielded: a drain or another input may now own admission.
+            // This request preceded inputs accepted during its selection window.
+            if (this.coreRestartDrains > 0 && this.usesCoreEngine(session))
+                return this.enqueueInput(session, prompt, true);
+            const ready = this.resolveInFlightSend(id, session, prompt, opts);
+            if ("result" in ready)
+                return ready.result;
+            session = ready.session;
+        }
+        // From this gate through runner.start/ownership registration there is no
+        // await, so the drain cannot observe idle and then admit a new Core turn.
+        if (this.coreRestartDrains > 0 && this.usesCoreEngine(session))
+            return this.enqueueInput(session, prompt);
         // 检测上一轮 assistant 是否有未配对的 AskUserQuestion tool_use（说明前一次
         // child 是被 SIGTERM 主动 kill 的，正在等用户回答）。如果有，把这次的输入打包
         // 成 tool_result 注入到 messages，让 UI 把卡片渲染为 answered。
@@ -1643,11 +1668,15 @@ export class StructuredSessionManager {
             await this.runStructuredStreaming(id, updated, cliClaudePrompt, requestId);
         }
     }
+    usesCoreEngine(session) {
+        if ((session.provider ?? session.structuredState?.provider) !== "pi")
+            return false;
+        const decided = session.structuredState?.engine;
+        return decided ? decided === "core" : session.employeeCandidates?.[session.employeeCandidateIndex ?? 0]?.engine === "sdk";
+    }
     async runPiTurn(id, updated, prompt, requestId) {
-        const employeeAgent = updated.employeeCandidates?.[updated.employeeCandidateIndex ?? 0];
-        // 会话已裁决过引擎就沿用（新建会话选了 Wand Agent 或 Pi CLI）；未裁决的旧会话/员工会话回落到候选配置。
-        const decidedEngine = updated.structuredState?.engine;
-        const sdkRequested = decidedEngine ? decidedEngine === "core" : employeeAgent?.engine === "sdk";
+        // Admission and dispatch must agree for both pinned and legacy employee engines.
+        const sdkRequested = this.usesCoreEngine(updated);
         // 没显式选择时对话框固定走 CLI；只有选定 Wand Agent 或员工候选配置 SDK 才是 core。
         // Register the selected Core runner synchronously before its lazy SDK/model
         // preparation. This preserves cancellation ownership and the restart drain;
@@ -1747,9 +1776,10 @@ export class StructuredSessionManager {
      * 期间改"已经被 flushNextQueuedMessage 拿走的队首"，但本方法只动 queue 数组
      * 本身，flushNext 在另一段时序里读 sessions.get(...) 当前快照，已经天然安全。
      */
-    reorderQueuedMessages(sessionId, order) {
+    reorderQueuedMessages(sessionId, order, expectedQueue) {
         const session = this.requireSession(sessionId);
         const queue = session.queuedMessages ?? [];
+        this.assertExpectedQueue(queue, expectedQueue);
         if (!Array.isArray(order) || order.length !== queue.length) {
             throw new Error("排序长度与当前队列不一致，请刷新后重试。");
         }
@@ -1816,6 +1846,9 @@ export class StructuredSessionManager {
     async promoteQueuedMessage(sessionId, index, expectedText, idempotencyKey) {
         const session = this.requireSession(sessionId);
         this.requireRecoveryControl(sessionId);
+        if (this.coreRestartDrains > 0 && this.usesCoreEngine(session)) {
+            throw new Error("服务正在排空 Wand Agent，排队消息已保留，请稍后重试立即发送。");
+        }
         if (idempotencyKey && this.seenIdempotencyKeys.has(`${sessionId}:${idempotencyKey}`)) {
             return session;
         }
@@ -1850,9 +1883,16 @@ export class StructuredSessionManager {
             return this.requireSession(sessionId);
         }
     }
+    assertExpectedQueue(queue, expected) {
+        if (expected !== undefined && (!Array.isArray(expected) || expected.length !== queue.length
+            || expected.some((text, index) => typeof text !== "string" || text !== queue[index]))) {
+            throw new Error("排队消息已变化，请刷新后重试。");
+        }
+    }
     /** Clear all queued messages. No-op when queue is already empty. */
-    clearQueuedMessages(sessionId) {
+    clearQueuedMessages(sessionId, expectedQueue) {
         const session = this.requireSession(sessionId);
+        this.assertExpectedQueue(session.queuedMessages ?? [], expectedQueue);
         if (!session.queuedMessages || session.queuedMessages.length === 0) {
             return session;
         }
@@ -2424,7 +2464,7 @@ export class StructuredSessionManager {
             data,
         });
     }
-    enqueueInput(session, prompt) {
+    enqueueInput(session, prompt, prepend = false) {
         if (isDuplicateStructuredQueueInput(session, prompt)) {
             const err = new Error("与上一条消息相同，已忽略，不会加入排队。");
             err.code = "duplicate_queued_message";
@@ -2433,7 +2473,7 @@ export class StructuredSessionManager {
         const queue = session.queuedMessages ?? [];
         if (queue.length >= 10)
             throw new Error("排队消息已满（最多 10 条），请等待当前消息处理完成。");
-        const queued = { ...session, queuedMessages: [...queue, prompt] };
+        const queued = { ...session, queuedMessages: prepend ? [prompt, ...queue] : [...queue, prompt] };
         this.sessions.set(session.id, queued);
         this.storage.updateSessionRuntimeMetadata(queued);
         this.emitStructuredSnapshot(queued);
@@ -2446,7 +2486,7 @@ export class StructuredSessionManager {
         if (!current || (current.queuedMessages?.length ?? 0) === 0) {
             return;
         }
-        if (current.structuredState?.inFlight) {
+        if (current.structuredState?.inFlight || (this.coreRestartDrains > 0 && this.usesCoreEngine(current))) {
             return;
         }
         const [nextInput, ...restQueue] = current.queuedMessages ?? [];
@@ -2465,9 +2505,10 @@ export class StructuredSessionManager {
         }
         catch (error) {
             console.error("[WAND] flushNextQueuedMessage failed:", error);
-            // 发送失败时把消息放回队首，避免永久丢失
+            // Only an explicit pre-execution rejection permits replay. A persisted
+            // runner failure or arbitrary exception can mean delivery is unknown.
             const afterFail = this.sessions.get(sessionId);
-            if (afterFail) {
+            if (afterFail && error instanceof UnacceptedStructuredInputError) {
                 const rescued = {
                     ...afterFail,
                     queuedMessages: [nextInput, ...(afterFail.queuedMessages ?? [])],
@@ -2476,6 +2517,17 @@ export class StructuredSessionManager {
                 this.storage.updateSessionRuntimeMetadata(rescued);
                 this.emitStructuredSnapshot(rescued);
             }
+            else if (afterFail && (afterFail.messages?.length ?? 0) <= (current.messages?.length ?? 0)) {
+                // If dispatch failed before a user turn was checkpointed, retain the
+                // original visibly for reconciliation, never as another sendable item.
+                const retained = { ...afterFail, messages: appendNoticeTurn(afterFail.messages, {
+                        role: "assistant", notice: true, content: [{ type: "text",
+                                text: "排队消息送达未确认，未自动重发。以下原文仅供核对，不是新的执行指令：\n\n" + nextInput }],
+                    }) };
+                this.saveAuthoritativeSession(retained);
+                this.sessions.set(sessionId, retained);
+                this.emitStructuredSnapshot(retained);
+            }
         }
     }
     emit(event) {
@@ -2560,6 +2612,27 @@ export class StructuredSessionManager {
             session,
             prompt,
             env: buildChildEnv(this.config.inheritEnv !== false),
+            ...(provider === "pi" && session.structuredState?.engine === "core" ? {
+                takeSteering: (turnState) => {
+                    const current = this.currentSessionForRequest(sessionId, requestId);
+                    if (!current || this.disposed || this.interruptedWith.has(sessionId) || this.coreRestartDrains > 0)
+                        return null;
+                    const [input, ...remaining] = current.queuedMessages ?? [];
+                    if (!input)
+                        return null;
+                    const preceding = turnState.blocks.length || turnState.result
+                        ? this.buildCompletedAssistantMessages(current, turnState) : [...(current.messages ?? [])];
+                    const consumed = {
+                        ...current, queuedMessages: remaining,
+                        messages: [...preceding, buildUserTurn(input, undefined, isoNow())],
+                    };
+                    // Persist queue removal and transcript together before exposing consumption.
+                    this.saveAuthoritativeSession(consumed);
+                    this.sessions.set(sessionId, consumed);
+                    this.emitStructuredSnapshot(consumed);
+                    return input;
+                },
+            } : {}),
         }, {
             isActive: () => this.isCurrentRequest(sessionId, requestId),
             onStdout: (text) => {

package/dist/system-ai-call.d.ts

@@ -21,9 +21,13 @@ export declare const SYSTEM_AI_PURPOSES: {
     readonly "user-memory": "短期习惯分析";
     readonly "employee-draft": "员工招聘草稿";
     readonly decision: "有界决策";
-    readonly "speech-polish": "口述文字整理";
 };
 export type SystemAiPurpose = keyof typeof SYSTEM_AI_PURPOSES;
+export declare const SYSTEM_AI_AUXILIARY_PURPOSES: ("decision" | "system-text" | "session-title" | "task-title" | "task-organize" | "conversation-organize-job" | "conversation-organize" | "conversation-summary" | "prompt-optimize" | "git-commit" | "git-tag" | "git-fallback" | "model-auto-assign" | "user-memory" | "employee-draft")[];
+/** Unknown/unspecified history and agent decisions are protected, even with system-ai provenance. */
+export declare function isRetainableSystemAiCall(session: {
+    automationId?: unknown;
+} | null | undefined): boolean;
 export interface AiCallTrace {
     readonly sessionId: string;
     candidateStarted(candidate: AiCliCandidate): void;