@oyasmi/pipiclaw 0.5.9 → 0.6.0

package/dist/agent/channel-runner.d.ts

@@ -4,6 +4,7 @@ import { type SandboxConfig } from "../sandbox.js";
 import { type BuiltInCommand } from "./commands.js";
 import { type AgentRunner } from "./types.js";
 export declare class ChannelRunner implements AgentRunner {
+    private readonly executor;
     private readonly sandboxConfig;
     private readonly channelId;
     private readonly channelDir;
@@ -43,6 +44,10 @@ export declare class ChannelRunner implements AgentRunner {
     private reloadSessionResources;
     private ensureSessionReady;
     private refreshSubAgentDiscovery;
+    private reportSettingsDiagnostics;
+    private reportConfigDiagnostics;
+    private buildRuntimeTools;
+    private rebuildSessionTools;
     private subscribeToSessionEvents;
     private buildFirstTurnMemoryBootstrap;
 }

package/dist/agent/channel-runner.js

@@ -12,10 +12,13 @@ import { getApiKeyForModel } from "../models/api-keys.js";
 import { resolveInitialModel } from "../models/utils.js";
 import { APP_HOME_DIR, AUTH_CONFIG_PATH, MODELS_CONFIG_PATH } from "../paths.js";
 import { createExecutor } from "../sandbox.js";
+import { loadSecurityConfigWithDiagnostics } from "../security/config.js";
 import { PipiclawSettingsManager } from "../settings.js";
+import { formatConfigDiagnostic } from "../shared/config-diagnostics.js";
 import { HAN_REGEX } from "../shared/text-utils.js";
 import { isRecord } from "../shared/type-guards.js";
 import { discoverSubAgents, formatSubAgentList } from "../subagents/discovery.js";
+import { loadToolsConfigWithDiagnostics } from "../tools/config.js";
 import { createPipiclawTools } from "../tools/index.js";
 import { createCommandExtension } from "./command-extension.js";
 import { renderBuiltInHelp } from "./commands.js";
@@ -54,6 +57,7 @@ export class ChannelRunner {
         this.channelId = channelId;
         this.channelDir = channelDir;
         const executor = createExecutor(sandboxConfig);
+        this.executor = executor;
         this.workspaceDir = resolve(dirname(channelDir));
         this.workspacePath = executor.getWorkspacePath(this.workspaceDir);
         // Initial skill summaries
@@ -63,6 +67,7 @@ export class ChannelRunner {
         const contextFile = join(channelDir, "context.jsonl");
         this.sessionManager = SessionManager.open(contextFile, channelDir);
         this.settingsManager = new PipiclawSettingsManager(APP_HOME_DIR);
+        this.reportSettingsDiagnostics();
         // Create AuthStorage and ModelRegistry
         const authStorage = AuthStorage.create(AUTH_CONFIG_PATH);
         this.modelRegistry = createModelRegistry(authStorage, MODELS_CONFIG_PATH);
@@ -71,19 +76,7 @@ export class ChannelRunner {
         log.logInfo(`Using model: ${this.activeModel.provider}/${this.activeModel.id} (${this.activeModel.name})`);
         this.subAgentDiscovery = this.refreshSubAgentDiscovery();
         // Create tools
-        const tools = createPipiclawTools({
-            executor,
-            getCurrentModel: () => this.activeModel,
-            getAvailableModels: () => this.modelRegistry.getAvailable(),
-            resolveApiKey: async (model) => getApiKeyForModel(this.modelRegistry, model),
-            workspaceDir: this.workspaceDir,
-            channelDir: this.channelDir,
-            workspacePath: this.workspacePath,
-            channelId: this.channelId,
-            sandboxConfig: this.sandboxConfig,
-            getSubAgentDiscovery: () => this.subAgentDiscovery,
-            getMemoryRecallSettings: () => this.settingsManager.getMemoryRecallSettings(),
-        });
+        const tools = this.buildRuntimeTools();
         // Create agent
         this.agent = new Agent({
             initialState: {
@@ -241,7 +234,10 @@ export class ChannelRunner {
                     this.runState.errorMessage &&
                     !this.runState.finalResponseDelivered) {
                     try {
-                        await ctx.replaceMessage("_Sorry, something went wrong_");
+                        const errorSummary = this.runState.errorMessage.length > 240
+                            ? `${this.runState.errorMessage.slice(0, 237)}...`
+                            : this.runState.errorMessage;
+                        await ctx.replaceMessage(`_Sorry, something went wrong._\n\n\`${errorSummary}\``);
                     }
                     catch (err) {
                         const errMsg = err instanceof Error ? err.message : String(err);
@@ -258,6 +254,16 @@ export class ChannelRunner {
                         log.logWarning("Failed to delete message for silent response", errMsg);
                     }
                 }
+                else if (this.runState.stopReason === "aborted" && !this.runState.finalResponseDelivered) {
+                    try {
+                        await ctx.deleteMessage();
+                        log.logInfo("Aborted response - discarded active delivery state");
+                    }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        log.logWarning("Failed to discard active delivery state after abort", errMsg);
+                    }
+                }
                 else if (finalOutcomeText && !this.runState.finalResponseDelivered) {
                     try {
                         await ctx.replaceMessage(finalOutcomeText);
@@ -388,10 +394,12 @@ export class ChannelRunner {
         await this.reloadSessionResources();
     }
     async reloadSessionResources() {
+        this.settingsManager.reload();
+        this.reportSettingsDiagnostics();
         const skills = loadPipiclawSkills(this.channelDir, this.workspacePath);
         this.currentSkills = skills;
         this.subAgentDiscovery = this.refreshSubAgentDiscovery();
-        this.firstTurnMemoryBootstrapPending = true;
+        this.rebuildSessionTools();
         await this.session.reload();
     }
     async ensureSessionReady() {
@@ -405,6 +413,42 @@ export class ChannelRunner {
         }
         return discovery;
     }
+    reportSettingsDiagnostics() {
+        for (const { scope, error } of this.settingsManager.drainErrors()) {
+            log.logWarning(`[${this.channelId}] Failed to load ${scope} settings`, `${error.message}\n${join(APP_HOME_DIR, "settings.json")}`);
+        }
+    }
+    reportConfigDiagnostics(diagnostics) {
+        for (const diagnostic of diagnostics) {
+            log.logWarning(`[${this.channelId}] ${formatConfigDiagnostic(diagnostic)}`, diagnostic.path);
+        }
+    }
+    buildRuntimeTools() {
+        const securityLoad = loadSecurityConfigWithDiagnostics(APP_HOME_DIR);
+        const toolsLoad = loadToolsConfigWithDiagnostics(APP_HOME_DIR);
+        this.reportConfigDiagnostics([...securityLoad.diagnostics, ...toolsLoad.diagnostics]);
+        return createPipiclawTools({
+            executor: this.executor,
+            getCurrentModel: () => this.activeModel,
+            getAvailableModels: () => this.modelRegistry.getAvailable(),
+            resolveApiKey: async (model) => getApiKeyForModel(this.modelRegistry, model),
+            workspaceDir: this.workspaceDir,
+            channelDir: this.channelDir,
+            workspacePath: this.workspacePath,
+            channelId: this.channelId,
+            sandboxConfig: this.sandboxConfig,
+            getSubAgentDiscovery: () => this.subAgentDiscovery,
+            getMemoryRecallSettings: () => this.settingsManager.getMemoryRecallSettings(),
+            securityConfig: securityLoad.config,
+            toolsConfig: toolsLoad.config,
+        });
+    }
+    rebuildSessionTools() {
+        const tools = this.buildRuntimeTools();
+        this.agent.setTools(tools);
+        this.session._baseToolsOverride =
+            Object.fromEntries(tools.map((tool) => [tool.name, tool]));
+    }
     // === Session event subscription ===
     subscribeToSessionEvents() {
         this.session.subscribe(async (event) => {

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export { renderSessionMemory, type SessionMemoryState, type SessionMemoryUpdateO
 export { runSidecarTask, type SidecarResult, type SidecarTask, } from "./memory/sidecar-worker.js";
 export { getApiKeyForModel } from "./models/api-keys.js";
 export { findExactModelReferenceMatch, findModelReferenceMatch, formatModelList, formatModelReference, resolveInitialModel, } from "./models/utils.js";
-export { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_CONFIG_PATH, SETTINGS_CONFIG_PATH, SUB_AGENTS_DIR, SUB_AGENTS_DIR_NAME, TOOLS_CONFIG_PATH, WORKSPACE_DIR, } from "./paths.js";
+export { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_CONFIG_PATH, SECURITY_CONFIG_PATH, SETTINGS_CONFIG_PATH, SUB_AGENTS_DIR, SUB_AGENTS_DIR_NAME, TOOLS_CONFIG_PATH, WORKSPACE_DIR, } from "./paths.js";
 export { ensureChannelDir, getChannelDir, getChannelDirName, } from "./runtime/channel-paths.js";
 export { createDingTalkContext } from "./runtime/delivery.js";
 export { type BusyMessageMode, DingTalkBot, type DingTalkConfig, type DingTalkContext, type DingTalkEvent, type DingTalkHandler, } from "./runtime/dingtalk.js";

package/dist/index.js

@@ -12,7 +12,7 @@ export { renderSessionMemory, updateChannelSessionMemory, } from "./memory/sessi
 export { runSidecarTask, } from "./memory/sidecar-worker.js";
 export { getApiKeyForModel } from "./models/api-keys.js";
 export { findExactModelReferenceMatch, findModelReferenceMatch, formatModelList, formatModelReference, resolveInitialModel, } from "./models/utils.js";
-export { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_CONFIG_PATH, SETTINGS_CONFIG_PATH, SUB_AGENTS_DIR, SUB_AGENTS_DIR_NAME, TOOLS_CONFIG_PATH, WORKSPACE_DIR, } from "./paths.js";
+export { APP_HOME_DIR, APP_NAME, AUTH_CONFIG_PATH, CHANNEL_CONFIG_PATH, MODELS_CONFIG_PATH, SECURITY_CONFIG_PATH, SETTINGS_CONFIG_PATH, SUB_AGENTS_DIR, SUB_AGENTS_DIR_NAME, TOOLS_CONFIG_PATH, WORKSPACE_DIR, } from "./paths.js";
 export { ensureChannelDir, getChannelDir, getChannelDirName, } from "./runtime/channel-paths.js";
 export { createDingTalkContext } from "./runtime/delivery.js";
 export { DingTalkBot, } from "./runtime/dingtalk.js";

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;
@@ -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/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,6 +125,17 @@ 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_ABORT_WAIT_MS = 5000;
@@ -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`);
@@ -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,5 +1,6 @@
 import * as log from "../log.js";
 const MIN_UPDATE_INTERVAL_MS = 800;
+const NO_CONTENT = "";
 class ChannelDeliveryController {
     constructor(event, bot, store) {
         this.event = event;
@@ -12,9 +13,12 @@ class ChannelDeliveryController {
         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 = [];
     }
     buildContext() {
@@ -37,19 +41,57 @@ 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.clearCardWarmup();
         this.progressText = this.progressText ? `${this.progressText}\n\n${text}` : text;
         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 +99,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,6 +115,7 @@ class ChannelDeliveryController {
     async replaceWithFinal(text) {
         if (this.closed || this.finalResponseDelivered)
             return;
+        this.clearCardWarmup();
         this.progressText = text;
         this.mode = "finalize-with-fallback";
         this.bumpRevision(true);
@@ -79,6 +123,7 @@ class ChannelDeliveryController {
     async silence() {
         if (this.closed)
             return;
+        this.clearCardWarmup();
         this.finalResponseDelivered = true;
         this.mode = "silent";
         this.bumpRevision(true);
@@ -138,8 +183,8 @@ class ChannelDeliveryController {
                         }
                     }
                     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.finalizeExistingCard(this.event.channelId, content ? this.progressText : NO_CONTENT);
                             if (!touchedRemote) {
                                 this.bot.discardCard(this.event.channelId);
                             }
@@ -160,7 +205,12 @@ class ChannelDeliveryController {
                         }
                     }
                     else if (mode === "silent") {
-                        this.bot.discardCard(this.event.channelId);
+                        if (this.cardWarmupTriggered) {
+                            touchedRemote = await this.bot.finalizeExistingCard(this.event.channelId, NO_CONTENT);
+                        }
+                        if (!touchedRemote) {
+                            this.bot.discardCard(this.event.channelId);
+                        }
                     }
                 }
                 catch (err) {
@@ -209,6 +259,7 @@ class ChannelDeliveryController {
             return;
         }
         this.closed = true;
+        this.clearCardWarmup();
         await this.flush();
     }
 }

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);