@oyasmi/pipiclaw 0.5.9 → 0.6.1

package/dist/memory/consolidation.js

@@ -4,7 +4,7 @@ import { splitH2Sections } from "../shared/markdown-sections.js";
 import { clipText } from "../shared/text-utils.js";
 import { buildStandardMessages } from "../shared/type-guards.js";
 import { appendChannelHistoryBlock, appendChannelMemoryUpdate, readChannelHistory, readChannelMemory, readChannelSession, rewriteChannelHistory, rewriteChannelMemory, } from "./files.js";
-import { runSidecarTask } from "./sidecar-worker.js";
+import { runRetriedSidecarTask, runSidecarTask } from "./sidecar-worker.js";
 const INLINE_TRANSCRIPT_MAX_CHARS = 28_000;
 const MEMORY_CLEANUP_LENGTH_THRESHOLD = 5_000;
 const MEMORY_UPDATE_BLOCK_THRESHOLD = 4;
@@ -12,8 +12,8 @@ const HISTORY_LENGTH_THRESHOLD = 8_000;
 const HISTORY_BLOCK_THRESHOLD = 5;
 const HISTORY_RECENT_BLOCKS_TO_KEEP = 3;
 const INLINE_CONSOLIDATION_TIMEOUT_MS = 20_000;
-const MEMORY_CLEANUP_TIMEOUT_MS = 30_000;
-const HISTORY_FOLDING_TIMEOUT_MS = 30_000;
+const MEMORY_CLEANUP_TIMEOUT_MS = 120_000;
+const HISTORY_FOLDING_TIMEOUT_MS = 120_000;
 const INLINE_CONSOLIDATION_SYSTEM_PROMPT = `You are a runtime memory consolidation worker for Pipiclaw.
 
 Return strict JSON only. Do not wrap in Markdown fences.
@@ -152,7 +152,16 @@ ${currentHistory || "(empty)"}
 
 Conversation chunk to persist:
 ${transcript || "(empty)"}`;
-    const rawResponse = await runWorkerPrompt("memory-inline-consolidation", options.model, options.resolveApiKey, INLINE_CONSOLIDATION_SYSTEM_PROMPT, prompt, INLINE_CONSOLIDATION_TIMEOUT_MS);
+    const result = await runRetriedSidecarTask({
+        name: "memory-inline-consolidation",
+        model: options.model,
+        resolveApiKey: options.resolveApiKey,
+        systemPrompt: INLINE_CONSOLIDATION_SYSTEM_PROMPT,
+        prompt,
+        timeoutMs: INLINE_CONSOLIDATION_TIMEOUT_MS,
+        parse: (text) => text.trim(),
+    });
+    const rawResponse = result.output;
     return parseConsolidationResponse(rawResponse);
 }
 export async function runInlineConsolidation(options) {

package/dist/memory/recall.d.ts

@@ -1,5 +1,5 @@
 import type { Api, Model } from "@mariozechner/pi-ai";
-import { type MemoryCandidate, type MemoryCandidateCache } from "./candidates.js";
+import { type MemoryCandidate, type MemoryCandidateStore } from "./candidates.js";
 export interface RecallRequest {
     query: string;
     workspaceDir: string;
@@ -12,7 +12,7 @@ export interface RecallRequest {
     autoRerank?: boolean;
     model: Model<Api>;
     resolveApiKey: (model: Model<Api>) => Promise<string>;
-    candidateCache?: MemoryCandidateCache;
+    candidateStore?: MemoryCandidateStore;
 }
 export interface RecalledMemory {
     source: MemoryCandidate["source"];

package/dist/memory/recall.js

@@ -1,6 +1,6 @@
 import { parseJsonObject } from "../shared/llm-json.js";
 import { HAN_REGEX } from "../shared/text-utils.js";
-import { buildMemoryCandidates } from "./candidates.js";
+import { buildMemoryCandidates, createMemoryCandidateStore, } from "./candidates.js";
 import { COMMON_CHINESE_WORDS } from "./chinese-words.js";
 import { runSidecarTask } from "./sidecar-worker.js";
 const RERANK_SYSTEM_PROMPT = `You are selecting which memory snippets are most relevant to the current user turn.
@@ -466,8 +466,7 @@ export async function recallRelevantMemory(request) {
     const candidates = await buildMemoryCandidates({
         workspaceDir: request.workspaceDir,
         channelDir: request.channelDir,
-        cache: request.candidateCache,
-    });
+    }, request.candidateStore ?? createMemoryCandidateStore());
     const filteredCandidates = request.allowedSources?.length
         ? candidates.filter((candidate) => request.allowedSources?.includes(candidate.source))
         : candidates;

package/dist/memory/session.js

@@ -6,7 +6,7 @@ import { splitH1Sections } from "../shared/markdown-sections.js";
 import { clipText } from "../shared/text-utils.js";
 import { buildStandardMessages, isRecord } from "../shared/type-guards.js";
 import { readChannelMemory, readChannelSession, rewriteChannelSession } from "./files.js";
-import { runSidecarTask, SidecarParseError } from "./sidecar-worker.js";
+import { runRetriedSidecarTask, SidecarParseError } from "./sidecar-worker.js";
 const SESSION_TRANSCRIPT_MAX_CHARS = 20_000;
 const SESSION_MEMORY_MAX_CHARS = 4_000;
 const SESSION_ITEM_LIMIT = 12;
@@ -220,7 +220,7 @@ export async function updateChannelSessionMemory(options) {
     const currentState = parseRenderedSessionMemory(currentSession);
     let update;
     try {
-        const result = await runSidecarTask({
+        const result = await runRetriedSidecarTask({
             name: "session-memory-update",
             model: options.model,
             resolveApiKey: options.resolveApiKey,

package/dist/memory/sidecar-worker.d.ts

@@ -24,3 +24,4 @@ export declare class SidecarParseError extends Error {
     constructor(taskName: string, rawText: string, cause: unknown);
 }
 export declare function runSidecarTask<T>(task: SidecarTask<T>): Promise<SidecarResult<T>>;
+export declare function runRetriedSidecarTask<T>(task: SidecarTask<T>): Promise<SidecarResult<T>>;

package/dist/memory/sidecar-worker.js

@@ -1,6 +1,8 @@
 import { Agent } from "@mariozechner/pi-agent-core";
 import { convertToLlm } from "@mariozechner/pi-coding-agent";
 import { extractAssistantText } from "../shared/text-utils.js";
+const SIDE_CAR_RETRY_DELAY_MS = 2_000;
+const SIDE_CAR_MAX_ATTEMPTS = 2;
 export class SidecarTimeoutError extends Error {
     constructor(taskName, timeoutMs) {
         super(`Sidecar task "${taskName}" timed out after ${timeoutMs}ms`);
@@ -18,6 +20,40 @@ export class SidecarParseError extends Error {
         this.cause = cause;
     }
 }
+function createAbortError(taskName, reason) {
+    return reason instanceof Error ? reason : new Error(`Sidecar task "${taskName}" aborted`);
+}
+function isExternalAbort(task) {
+    return task.signal?.aborted === true;
+}
+function delay(ms, task) {
+    if (ms <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const signal = task.signal;
+        const timer = setTimeout(() => {
+            removeAbortListener();
+            resolve();
+        }, ms);
+        const abort = () => {
+            clearTimeout(timer);
+            removeAbortListener();
+            reject(createAbortError(task.name, signal?.reason));
+        };
+        const removeAbortListener = () => {
+            signal?.removeEventListener("abort", abort);
+        };
+        if (!signal) {
+            return;
+        }
+        if (signal.aborted) {
+            abort();
+            return;
+        }
+        signal.addEventListener("abort", abort, { once: true });
+    });
+}
 export async function runSidecarTask(task) {
     const apiKey = await task.resolveApiKey(task.model);
     const worker = new Agent({
@@ -76,7 +112,7 @@ export async function runSidecarTask(task) {
         blockers.push(new Promise((_, reject) => {
             const abort = () => {
                 abortWorker();
-                reject(signal.reason instanceof Error ? signal.reason : new Error(`Sidecar task "${task.name}" aborted`));
+                reject(createAbortError(task.name, signal.reason));
             };
             if (signal.aborted) {
                 abort();
@@ -96,3 +132,22 @@ export async function runSidecarTask(task) {
         removeAbortListener();
     }
 }
+export async function runRetriedSidecarTask(task) {
+    let lastError;
+    for (let attempt = 1; attempt <= SIDE_CAR_MAX_ATTEMPTS; attempt++) {
+        if (isExternalAbort(task)) {
+            throw createAbortError(task.name, task.signal?.reason);
+        }
+        try {
+            return await runSidecarTask(task);
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= SIDE_CAR_MAX_ATTEMPTS || error instanceof SidecarParseError || isExternalAbort(task)) {
+                throw error;
+            }
+            await delay(SIDE_CAR_RETRY_DELAY_MS, task);
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(`Sidecar task "${task.name}" failed`);
+}

package/dist/paths.d.ts

@@ -8,3 +8,4 @@ export declare const AUTH_CONFIG_PATH: string;
 export declare const MODELS_CONFIG_PATH: string;
 export declare const SETTINGS_CONFIG_PATH: string;
 export declare const TOOLS_CONFIG_PATH: string;
+export declare const SECURITY_CONFIG_PATH: string;

package/dist/paths.js

@@ -10,3 +10,4 @@ export const AUTH_CONFIG_PATH = join(APP_HOME_DIR, "auth.json");
 export const MODELS_CONFIG_PATH = join(APP_HOME_DIR, "models.json");
 export const SETTINGS_CONFIG_PATH = join(APP_HOME_DIR, "settings.json");
 export const TOOLS_CONFIG_PATH = join(APP_HOME_DIR, "tools.json");
+export const SECURITY_CONFIG_PATH = join(APP_HOME_DIR, "security.json");

package/dist/runtime/bootstrap.d.ts

@@ -10,6 +10,7 @@ export interface BootstrapPaths {
     modelsConfigPath: string;
     settingsConfigPath: string;
     toolsConfigPath: string;
+    securityConfigPath: string;
 }
 export interface BootstrapIO {
     log: (...args: unknown[]) => void;

package/dist/runtime/bootstrap.js

@@ -5,8 +5,12 @@ import { getOrCreateRunner } from "../agent/index.js";
 import { resetRunner } from "../agent/runner-factory.js";
 import * as log from "../log.js";
 import { ensureChannelMemoryFilesSync } from "../memory/files.js";
-import { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_CONFIG_PATH, SETTINGS_CONFIG_PATH, TOOLS_CONFIG_PATH, WORKSPACE_DIR, } from "../paths.js";
+import { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_CONFIG_PATH, SECURITY_CONFIG_PATH, SETTINGS_CONFIG_PATH, TOOLS_CONFIG_PATH, WORKSPACE_DIR, } from "../paths.js";
 import { parseSandboxArg, validateSandbox } from "../sandbox.js";
+import { loadSecurityConfigWithDiagnostics } from "../security/config.js";
+import { PipiclawSettingsManager } from "../settings.js";
+import { formatConfigDiagnostic } from "../shared/config-diagnostics.js";
+import { loadToolsConfigWithDiagnostics } from "../tools/config.js";
 import { ensureChannelDir } from "./channel-paths.js";
 import { createDingTalkContext } from "./delivery.js";
 import { DingTalkBot, } from "./dingtalk.js";
@@ -121,8 +125,19 @@ const TOOLS_CONFIG_TEMPLATE = {
         "If needed, copy _examples.proxy to tools.web.proxy.",
     ],
 };
+const SECURITY_CONFIG_TEMPLATE = {
+    pathGuard: {
+        enabled: true,
+    },
+    commandGuard: {
+        enabled: true,
+    },
+    networkGuard: {
+        enabled: false,
+    },
+};
 const SHUTDOWN_WAIT_MS = 15000;
-const SHUTDOWN_FLUSH_WAIT_MS = 25000;
+const SHUTDOWN_FLUSH_WAIT_MS = 45000;
 const SHUTDOWN_ABORT_WAIT_MS = 5000;
 export const DEFAULT_BOOTSTRAP_PATHS = {
     appName: APP_NAME,
@@ -133,6 +148,7 @@ export const DEFAULT_BOOTSTRAP_PATHS = {
     modelsConfigPath: MODELS_CONFIG_PATH,
     settingsConfigPath: SETTINGS_CONFIG_PATH,
     toolsConfigPath: TOOLS_CONFIG_PATH,
+    securityConfigPath: SECURITY_CONFIG_PATH,
 };
 export class BootstrapExitError extends Error {
     constructor(code, message) {
@@ -181,6 +197,7 @@ export function bootstrapAppHome(paths = DEFAULT_BOOTSTRAP_PATHS) {
     writeJsonFileIfMissing(paths.modelsConfigPath, MODELS_CONFIG_TEMPLATE, "models.json", created);
     writeJsonFileIfMissing(paths.settingsConfigPath, {}, "settings.json", created);
     writeJsonFileIfMissing(paths.toolsConfigPath, TOOLS_CONFIG_TEMPLATE, "tools.json", created);
+    writeJsonFileIfMissing(paths.securityConfigPath, SECURITY_CONFIG_TEMPLATE, "security.json", created);
     return { created, channelTemplateCreated };
 }
 function isPlaceholderString(value) {
@@ -305,6 +322,14 @@ export function createRuntimeContext(options) {
     const activeTasks = new Set();
     let shuttingDown = false;
     let shutdownPromise = null;
+    const archiveIncomingMessage = async (channelId, message, contextLabel) => {
+        try {
+            await store.logMessage(channelId, message);
+        }
+        catch (err) {
+            log.logWarning(`[${channelId}] Failed to archive ${contextLabel}`, err instanceof Error ? err.message : String(err));
+        }
+    };
     const getState = (channelId) => {
         let state = channelStates.get(channelId);
         if (!state) {
@@ -328,6 +353,7 @@ export function createRuntimeContext(options) {
             const state = channelStates.get(channelId);
             if (state?.running) {
                 state.stopRequested = true;
+                _bot.discardCard(channelId);
                 void state.runner.abort().catch((err) => {
                     log.logWarning(`[${channelId}] Failed to abort run`, err instanceof Error ? err.message : String(err));
                 });
@@ -340,7 +366,7 @@ export function createRuntimeContext(options) {
             }
             const state = getState(event.channelId);
             const trimmedQueueText = queueText.trim();
-            await store.logMessage(event.channelId, {
+            await archiveIncomingMessage(event.channelId, {
                 date: new Date().toISOString(),
                 ts: event.ts,
                 user: event.user,
@@ -349,7 +375,7 @@ export function createRuntimeContext(options) {
                 isBot: false,
                 deliveryMode: mode,
                 skipContextSync: true,
-            });
+            }, `${mode} message`);
             try {
                 if (mode === "followUp") {
                     await state.runner.queueFollowUp(trimmedQueueText, event.userName);
@@ -380,15 +406,15 @@ export function createRuntimeContext(options) {
             const task = (async () => {
                 state.running = true;
                 state.stopRequested = false;
-                await store.logMessage(event.channelId, {
-                    date: new Date().toISOString(),
-                    ts: event.ts,
-                    user: event.user,
-                    userName: event.userName,
-                    text: event.text,
-                    isBot: false,
-                });
                 try {
+                    await archiveIncomingMessage(event.channelId, {
+                        date: new Date().toISOString(),
+                        ts: event.ts,
+                        user: event.user,
+                        userName: event.userName,
+                        text: event.text,
+                        isBot: false,
+                    }, "user message");
                     const ctx = createDingTalkContext(event, bot, store);
                     const builtInCommand = parseBuiltInCommand(event.text);
                     if (builtInCommand) {
@@ -397,6 +423,9 @@ export function createRuntimeContext(options) {
                         return;
                     }
                     log.logInfo(`[${event.channelId}] Starting run: ${event.text.substring(0, 50)}`);
+                    if (!_isEvent) {
+                        ctx.primeCard(350);
+                    }
                     const result = await state.runner.run(ctx, store);
                     if (result.stopReason === "aborted" && state.stopRequested) {
                         log.logInfo(`[${event.channelId}] Stopped`);
@@ -423,7 +452,7 @@ export function createRuntimeContext(options) {
         : new DingTalkBot(handler, options.dingtalkConfig);
     const eventsWatcher = options.createEventsWatcher
         ? options.createEventsWatcher(options.paths.workspaceDir, bot)
-        : createEventsWatcher(options.paths.workspaceDir, bot);
+        : createEventsWatcher(options.paths.workspaceDir, bot, loadSecurityConfigWithDiagnostics(options.paths.appHomeDir).config.commandGuard);
     const shutdownWithReason = async (reason = "manual") => {
         if (shutdownPromise) {
             return shutdownPromise;
@@ -511,6 +540,16 @@ export async function bootstrap(argv, options = {}) {
     }
     const dingtalkConfig = loadConfig(paths, io);
     dingtalkConfig.stateDir = paths.workspaceDir;
+    const settingsManager = new PipiclawSettingsManager(paths.appHomeDir);
+    for (const { scope, error } of settingsManager.drainErrors()) {
+        log.logWarning(`Failed to load ${scope} settings`, `${error.message}\n${paths.settingsConfigPath}`);
+    }
+    for (const diagnostic of loadToolsConfigWithDiagnostics(paths.appHomeDir).diagnostics) {
+        log.logWarning(formatConfigDiagnostic(diagnostic), diagnostic.path);
+    }
+    for (const diagnostic of loadSecurityConfigWithDiagnostics(paths.appHomeDir).diagnostics) {
+        log.logWarning(formatConfigDiagnostic(diagnostic), diagnostic.path);
+    }
     await validateSandbox(sandbox);
     log.logStartup(paths.workspaceDir, sandbox.type === "host" ? "host" : `docker:${sandbox.container}`);
     const runtime = createRuntimeContext({

package/dist/runtime/delivery.js

@@ -1,21 +1,30 @@
 import * as log from "../log.js";
 const MIN_UPDATE_INTERVAL_MS = 800;
+const NO_CONTENT = "";
 class ChannelDeliveryController {
     constructor(event, bot, store) {
         this.event = event;
         this.bot = bot;
         this.store = store;
-        this.progressText = "";
+        this.progressSegments = [];
+        this.cachedProgressText = "";
+        this.progressTextDirty = false;
         this.mode = "progress";
         this.desiredRevision = 0;
         this.appliedRevision = 0;
         this.running = false;
         this.closed = false;
         this.finalResponseDelivered = false;
+        this.cardWarmupScheduled = false;
+        this.cardWarmupTriggered = false;
         this.progressWindowStartedAt = 0;
         this.lastDeliveredAt = 0;
         this.timer = null;
+        this.cardWarmupTimer = null;
         this.flushWaiters = [];
+        this.sentProgressChars = 0;
+        this.replayRequired = false;
+        this.finalReplacementText = "";
     }
     buildContext() {
         return {
@@ -37,19 +46,61 @@ class ChannelDeliveryController {
             setTyping: async (_isTyping) => { },
             setWorking: async (_working) => { },
             deleteMessage: async () => this.silence(),
+            primeCard: (delayMs) => this.primeCard(delayMs),
             flush: async () => this.flush(),
             close: async () => this.close(),
         };
     }
+    primeCard(delayMs) {
+        if (this.closed || this.finalResponseDelivered || this.cardWarmupScheduled || this.cardWarmupTriggered) {
+            return;
+        }
+        this.cardWarmupScheduled = true;
+        this.cardWarmupTimer = setTimeout(() => {
+            this.cardWarmupScheduled = false;
+            this.cardWarmupTimer = null;
+            void this.triggerCardWarmup();
+        }, Math.max(0, delayMs));
+    }
+    async triggerCardWarmup() {
+        if (this.closed || this.finalResponseDelivered || this.desiredRevision > 0) {
+            return;
+        }
+        this.cardWarmupTriggered = true;
+        try {
+            await this.bot.ensureCard(this.event.channelId);
+        }
+        catch (err) {
+            log.logWarning(`[${this.event.channelId}] Failed to warm AI card`, err instanceof Error ? err.message : String(err));
+            this.bot.discardCard(this.event.channelId);
+        }
+    }
+    clearCardWarmup() {
+        this.cardWarmupScheduled = false;
+        if (this.cardWarmupTimer) {
+            clearTimeout(this.cardWarmupTimer);
+            this.cardWarmupTimer = null;
+        }
+    }
+    archiveBotResponse(text) {
+        void this.store.logBotResponse(this.event.channelId, text, Date.now().toString()).catch((err) => {
+            log.logWarning(`[${this.event.channelId}] Failed to archive bot response`, err instanceof Error ? err.message : String(err));
+        });
+    }
     async appendProgress(text, shouldLog) {
         if (this.closed || this.finalResponseDelivered || !text.trim())
             return;
-        this.progressText = this.progressText ? `${this.progressText}\n\n${text}` : text;
+        this.clearCardWarmup();
+        if (this.progressSegments.length > 0) {
+            this.progressSegments.push("\n\n");
+        }
+        this.progressSegments.push(text);
+        this.progressTextDirty = true;
         if (this.progressWindowStartedAt === 0) {
             this.progressWindowStartedAt = Date.now();
         }
         if (shouldLog) {
-            await this.store.logBotResponse(this.event.channelId, text, Date.now().toString());
+            this.archiveBotResponse(text);
         }
         this.mode = "progress";
         this.bumpRevision(false);
@@ -57,8 +108,9 @@ class ChannelDeliveryController {
     async sendFinal(text, shouldLog) {
         if (this.closed || this.finalResponseDelivered)
             return this.finalResponseDelivered;
+        this.clearCardWarmup();
         if (shouldLog) {
-            await this.store.logBotResponse(this.event.channelId, text, Date.now().toString());
+            this.archiveBotResponse(text);
         }
         const delivered = await this.bot.sendPlain(this.event.channelId, text);
         if (!delivered) {
@@ -72,13 +124,15 @@ class ChannelDeliveryController {
     async replaceWithFinal(text) {
         if (this.closed || this.finalResponseDelivered)
             return;
-        this.progressText = text;
+        this.clearCardWarmup();
+        this.finalReplacementText = text;
         this.mode = "finalize-with-fallback";
         this.bumpRevision(true);
     }
     async silence() {
         if (this.closed)
             return;
+        this.clearCardWarmup();
         this.finalResponseDelivered = true;
         this.mode = "silent";
         this.bumpRevision(true);
@@ -114,6 +168,7 @@ class ChannelDeliveryController {
         try {
             while (this.appliedRevision < this.desiredRevision) {
                 const mode = this.mode;
+                const progressText = this.getProgressText();
                 const throttleBaseAt = this.lastDeliveredAt > 0 ? this.lastDeliveredAt : this.progressWindowStartedAt;
                 if (mode === "progress" && throttleBaseAt > 0) {
                     const remaining = MIN_UPDATE_INTERVAL_MS - (Date.now() - throttleBaseAt);
@@ -126,31 +181,48 @@ class ChannelDeliveryController {
                     }
                 }
                 const revision = this.desiredRevision;
-                const content = this.progressText.trim();
+                const content = progressText.trim();
+                const replacementText = this.finalReplacementText;
                 let touchedRemote = false;
                 try {
                     if (mode === "progress") {
                         if (content) {
-                            touchedRemote = await this.bot.streamToCard(this.event.channelId, this.progressText);
+                            const nextSentChars = progressText.length;
+                            if (this.replayRequired) {
+                                touchedRemote = await this.bot.replaceCard(this.event.channelId, progressText);
+                            }
+                            else {
+                                const delta = progressText.slice(this.sentProgressChars);
+                                touchedRemote = delta ? await this.bot.appendToCard(this.event.channelId, delta) : true;
+                            }
                             if (!touchedRemote) {
                                 this.bot.discardCard(this.event.channelId);
+                                this.replayRequired = true;
+                            }
+                            else {
+                                this.sentProgressChars = nextSentChars;
+                                this.replayRequired = false;
                             }
                         }
                     }
                     else if (mode === "finalize-existing") {
-                        if (content) {
-                            touchedRemote = await this.bot.finalizeExistingCard(this.event.channelId, this.progressText);
+                        if (content || this.cardWarmupTriggered) {
+                            touchedRemote = await this.bot.replaceCard(this.event.channelId, content ? progressText : NO_CONTENT, true);
                             if (!touchedRemote) {
                                 this.bot.discardCard(this.event.channelId);
                             }
+                            else {
+                                this.sentProgressChars = progressText.length;
+                                this.replayRequired = false;
+                            }
                         }
                         else {
                             this.bot.discardCard(this.event.channelId);
                         }
                     }
                     else if (mode === "finalize-with-fallback") {
-                        if (content) {
-                            touchedRemote = await this.bot.finalizeCard(this.event.channelId, this.progressText);
+                        if (replacementText.trim()) {
+                            touchedRemote = await this.bot.finalizeCard(this.event.channelId, replacementText);
                             if (!touchedRemote) {
                                 this.bot.discardCard(this.event.channelId);
                             }
@@ -160,12 +232,20 @@ class ChannelDeliveryController {
                         }
                     }
                     else if (mode === "silent") {
-                        this.bot.discardCard(this.event.channelId);
+                        if (this.cardWarmupTriggered) {
+                            touchedRemote = await this.bot.replaceCard(this.event.channelId, NO_CONTENT, true);
+                        }
+                        if (!touchedRemote) {
+                            this.bot.discardCard(this.event.channelId);
+                        }
                     }
                 }
                 catch (err) {
                     log.logWarning(`[${this.event.channelId}] Delivery sync failed`, err instanceof Error ? err.message : String(err));
                     this.bot.discardCard(this.event.channelId);
+                    if (mode === "progress") {
+                        this.replayRequired = true;
+                    }
                 }
                 if (touchedRemote) {
                     this.lastDeliveredAt = Date.now();
@@ -209,8 +289,17 @@ class ChannelDeliveryController {
             return;
         }
         this.closed = true;
+        this.clearCardWarmup();
         await this.flush();
     }
+    getProgressText() {
+        if (!this.progressTextDirty) {
+            return this.cachedProgressText;
+        }
+        this.cachedProgressText = this.progressSegments.join("");
+        this.progressTextDirty = false;
+        return this.cachedProgressText;
+    }
 }
 export function createDingTalkContext(event, bot, store) {
     return new ChannelDeliveryController(event, bot, store).buildContext();

package/dist/runtime/dingtalk.d.ts

@@ -34,6 +34,7 @@ export interface DingTalkContext {
     setTyping: (isTyping: boolean) => Promise<void>;
     setWorking: (working: boolean) => Promise<void>;
     deleteMessage: () => Promise<void>;
+    primeCard: (delayMs: number) => void;
     flush: () => Promise<void>;
     close: () => Promise<void>;
 }
@@ -61,6 +62,7 @@ export declare class DingTalkBot {
     private isReconnecting;
     private isStopped;
     private reconnectAttempts;
+    private hasReportedReady;
     private processedIds;
     private processedIdsOrder;
     constructor(handler: DingTalkHandler, config: DingTalkConfig);
@@ -92,7 +94,15 @@ export declare class DingTalkBot {
      */
     ensureCard(channelId: string): Promise<void>;
     /**
-     * Stream content to the active AI Card for a channel.
+     * Replace the active card content with a full snapshot.
+     */
+    replaceCard(channelId: string, content: string, finalize?: boolean, failed?: boolean): Promise<boolean>;
+    /**
+     * Append a delta to the active card transcript.
+     */
+    appendToCard(channelId: string, content: string, finalize?: boolean, failed?: boolean): Promise<boolean>;
+    /**
+     * Stream content to the active AI Card for a channel using full replacement semantics.
      */
     streamToCard(channelId: string, content: string, finalize?: boolean): Promise<boolean>;
     /**