qlogicagent 2.16.2 → 2.16.4

package/dist/types/agent/tool-loop/artifact-final-contract.d.ts

@@ -12,6 +12,10 @@ export interface ArtifactContractState {
     browserVerified: boolean;
     browserEvidence: string[];
     browserFailureEvidence: string[];
+    /** Build/test verification: a test/build/compile command ran and passed (exit 0). */
+    buildVerified: boolean;
+    buildEvidence: string[];
+    buildFailureEvidence: string[];
 }
 export interface ArtifactContractEventPayload {
     artifactRoot?: string;
@@ -34,6 +38,7 @@ export interface TaskContractItem {
 }
 export declare function createArtifactContractState(inputMessages: readonly ChatMessage[]): ArtifactContractState;
 export declare function requiresBrowserAcceptance(inputMessages: readonly ChatMessage[]): boolean;
+export declare function requiresBuildVerification(inputMessages: readonly ChatMessage[]): boolean;
 export declare function requiresResearchQualityGate(inputMessages: readonly ChatMessage[]): boolean;
 export declare function hasFinalStatusContract(content: string): boolean;
 export declare function hasResearchQualityGate(content: string): boolean;

package/dist/types/agent/tool-loop/completion-action-policy.d.ts

@@ -1,5 +1,5 @@
 import type { AgentLogger, ChatMessage, ThinkingBlock, ToolLoopTransition } from "../types.js";
-export type CompletionActionPolicyReason = "file_action_verification" | "explicit_required_file_verification" | "explicit_extra_file_verification" | "artifact_index_evidence_verification" | "multi_file_skeleton_verification";
+export type CompletionActionPolicyReason = "file_action_verification" | "explicit_required_file_verification" | "explicit_extra_file_verification" | "artifact_index_evidence_verification" | "multi_file_skeleton_verification" | "forbidden_file_creation";
 export interface CompletionActionPolicyInput {
     inputMessages: readonly ChatMessage[];
     messages: unknown[];
@@ -34,5 +34,6 @@ export declare function buildPrematureCompletionArtifactBlock(input: {
     messages: unknown[];
     toolCall: CandidateToolCall;
 }): string | undefined;
+export declare function findForbiddenCreatedFiles(inputMessages: readonly ChatMessage[], messages: unknown[]): string[];
 export declare function resolveCompletionActionPolicy(input: CompletionActionPolicyInput): CompletionActionPolicyDecision | null;
 export {};

package/dist/types/agent/tool-loop.d.ts

@@ -18,7 +18,7 @@
  *
  * Zero imports from express/pg/ioredis/ws.
  */
-import type { AgentLogger, ChatMessage, ToolDefinition, ToolInvoker, TurnEvent, HookRegistry, LLMTransport } from "./types.js";
+import type { AgentLogger, ChatMessage, ToolDefinition, ToolInvoker, TurnEvent, HookRegistry, LLMTransport, MaintainedDocumentIndex } from "./types.js";
 import type { ToolLoopRuntimePorts } from "../runtime/ports/index.js";
 export interface ToolLoopParams {
     turnId: string;
@@ -39,6 +39,11 @@ export interface ToolLoopParams {
     modelMaxOutputTokens?: number;
     /** Tool choice strategy (default "auto") */
     toolChoice?: "auto" | "none" | "required";
+    /**
+     * Build/test verification gate (lever ②). Default true. Set false to disable the
+     * "fix-and-rerun until the test/build passes" recovery — used for A/B measurement.
+     */
+    buildVerificationGate?: boolean;
     /** Parent fork depth (0 = top-level) */
     parentDepth?: number;
     /** Tool eligibility context for policy-based filtering */
@@ -101,6 +106,21 @@ export interface ToolLoopParams {
     runtimePorts: ToolLoopRuntimePorts;
     signal?: AbortSignal;
 }
+/** Crossing this many actions on the SAME target within a turn flags a no-progress candidate. */
+export declare const NO_PROGRESS_TARGET_THRESHOLD = 4;
+/**
+ * [lever 3 — observe-only] Identify the "target" a tool call acts on, for churn counting:
+ * the file path for write/edit/patch, the normalized command for exec. Returns null for
+ * tools whose repetition isn't a stuck-signal (read, search, etc.). Exported for testing.
+ */
+export declare function noProgressTargetKey(toolName: string, rawArguments: string): string | null;
+export declare function buildBenchmarkStateMaintenanceInstruction(documents: ReadonlyMap<string, MaintainedDocumentIndex>, turn: number): string | null;
+export declare function benchmarkStateMaintenanceWriteValidation(maintainedDocuments: ReadonlyMap<string, MaintainedDocumentIndex>, filePath: string, rawArguments: string): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
 /**
  * Execute the tool loop -CC query.ts queryLoop() aligned.
  *

package/dist/types/cli/cli-acp-request-handler.d.ts

@@ -7,5 +7,8 @@ export interface CliAcpRequestHandlerHost extends acpSession.AcpSessionHost {
     /** Id of the turn currently running; used to key cancel requests. */
     currentTurnId?: string;
     permissionChecker?: PermissionApprovalResolver | null;
+    /** LH-10: propagate an explicit cancel to the background tasks the given (or
+     *  current) session launched. No-op if the host has no task registry. */
+    cancelBackgroundTasksForSession?(sessionId?: string): void;
 }
 export declare function createCliAcpRequestHandler(host: CliAcpRequestHandlerHost, packageVersion: string, extendedHost?: acpExtended.AcpExtendedHost): AcpRequestHandler;

package/dist/types/cli/core-tools/agent-tool-service.d.ts

@@ -11,6 +11,9 @@ export interface AgentToolServiceHost {
     readonly currentApiKey: string;
     readonly currentModel: string;
     readonly currentTurnId?: string;
+    /** Session id of the launching turn — stamped on background tasks so an
+     *  explicit cancel can reach the work this session spawned (LH-10). */
+    readonly currentSessionId?: string;
     sendNotification(method: string, params: Record<string, unknown>): void;
     /** Unified background execution registry. Required for background=true forks. */
     getBackgroundTasks(): BackgroundTaskManager | null;

package/dist/types/cli/handlers/control-handler.d.ts

@@ -15,6 +15,9 @@ export interface ControlHandlerHost {
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
     sendNotification<M extends keyof NotificationMethodMap>(method: M, params: NotificationMethodMap[M]): void;
     ensureDefaultProject(): void;
+    /** LH-10: propagate an explicit cancel to the background tasks the current
+     *  session launched. No-op if the host has no task registry. */
+    cancelBackgroundTasksForSession?(sessionId?: string): void;
     /** Actual registered RPC method names (single source of truth = the live registry), so the
      *  initialize capability declaration never drifts from what's really handled. */
     getRegisteredMethods(): string[];

package/dist/types/cli/stdio-acp-request-host.d.ts

@@ -16,6 +16,7 @@ export type StdioAcpRequestHostSource = Pick<CliAcpRequestHandlerHost, "activeTu
     petRuntime: unknown;
     projectMemoryStoreFactory: unknown;
     toolCatalog: unknown;
+    cancelBackgroundTasksForSession(sessionId?: string): void;
     configureTurnMedia(config: Record<string, unknown> | undefined, turnId: string): void;
     drainPendingTaskNotifications(): string[];
     resolveAgent(config: unknown): unknown;

package/dist/types/cli/stdio-server.d.ts

@@ -106,6 +106,11 @@ export declare class StdioServer {
     set currentSessionId(v: string);
     get currentTurnId(): string;
     set currentTurnId(v: string);
+    /** LH-10: an explicit cancel of a session stops the background tasks that
+     *  session launched — the forked agent + the exec processes it spawned —
+     *  instead of leaving them running as zombies. Keyed by session id, which is
+     *  shared across the client/agent boundary (turn ids are not). */
+    cancelBackgroundTasksForSession(sessionId?: string): void;
     get sessionState(): SessionState | null;
     set sessionState(v: SessionState | null);
     get sessionLlmConfig(): SessionLlmConfig;

package/dist/types/protocol/wire/acp-protocol.d.ts

@@ -168,6 +168,9 @@ export interface AcpSessionPromptParams {
 export interface AcpSessionPromptResult {
     /** Stop reason (required by ACP standard). */
     stopReason: AcpStopReason;
+    /** Final assistant text for the turn (non-standard extension; emitted on end_turn). Lets the host
+     *  read the completed message alongside the streamed session/update chunks. */
+    content?: string;
     /** Token usage for this turn. */
     usage?: AcpUsage;
     /** Model that actually ran the turn (agent-resolved). Lets the host attribute

package/dist/types/runtime/execution/background-progress-context.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Background-task liveness context — AsyncLocalStorage progress signal (LH-6).
+ *
+ * A forked background agent's idle-reclaim window (BackgroundTaskManager) is
+ * pushed forward by markProgress on every SUBAGENT TURN EVENT (delta / tool
+ * call / tool result). But a single long-running exec emits its stdout/stderr
+ * as tool-INTERNAL chunks, not turn events — so a 12-minute build that prints
+ * steadily would otherwise look idle and be wrongly reclaimed.
+ *
+ * The background runner stores its markProgress callback here (for the whole
+ * async subtree of the fork); exec progress calls signalBackgroundProgress() on
+ * every output chunk to push the window forward, so any actively-producing exec
+ * keeps its enclosing background task alive even between turn events.
+ *
+ * No-op at top level (no enclosing background runner) — a foreground exec just
+ * finds an empty store.
+ */
+/** Run fn with a liveness callback bound for the current async subtree. */
+export declare function runWithBackgroundProgress<T>(onProgress: () => void, fn: () => T): T;
+/** Signal liveness to the enclosing background runner, if any. No-op at top level. */
+export declare function signalBackgroundProgress(): void;

package/dist/types/runtime/infra/acp-detector.d.ts

@@ -138,6 +138,9 @@ export declare class AcpDetector {
     private cache;
     private configStore;
     private keySources;
+    /** Shared in-flight async scan so concurrent scanAsync() callers (startup warm + a racing RPC)
+     *  collapse onto ONE scan instead of each spawning its own probe storm. Cleared when it settles. */
+    private scanInFlight;
     /**
      * Provide the config store data so detector can populate `hasConfig` field
      * and include user-registered custom agents.
@@ -150,12 +153,32 @@ export declare class AcpDetector {
      * @param force - Clear cache and re-scan.
      */
     scan(force?: boolean): AgentDescriptor[];
+    /**
+     * Async, NON-BLOCKING twin of {@link scan}. Probes every backend CONCURRENTLY off the event loop
+     * (async `where`/`which` + version probes), so the engine's single-threaded loop keeps servicing
+     * ACP requests while detection runs — fixing the bug where a cold synchronous scan (11–18s here,
+     * 60s+ with more/slower CLIs) starved an already-dispatched `x/product.confirm` until it tripped
+     * the UI's 60s timeout. Populates the SAME cache as scan(), so a later sync list()/scan(false)
+     * returns instantly. Concurrent callers share one in-flight scan ({@link scanInFlight}).
+     *
+     * @param force - Bypass the fresh-cache short-circuit and re-probe.
+     */
+    scanAsync(force?: boolean): Promise<AgentDescriptor[]>;
+    private runScanAsync;
     /** Return cached results without IO. */
     list(): AgentDescriptor[];
     /** Clear the detection cache. */
     clearCache(): void;
     private detectBackend;
+    /** Async, NON-BLOCKING twin of {@link detectBackend} — identical detection, async probes. */
+    private detectBackendAsync;
+    /** Build a backend's descriptor from already-resolved cliPath/version. Shared by the sync and async
+     *  detection paths so they can never drift (status rules, copilot's version-required gate, etc.). */
+    private assembleBackendDescriptor;
     private detectCustomAgent;
+    /** Async, NON-BLOCKING twin of {@link detectCustomAgent}. */
+    private detectCustomAgentAsync;
+    private assembleCustomAgentDescriptor;
     private hasAgentConfig;
     /**
      * Descriptor for qlogicagent participating in Solo/Product as a self-hosted ACP agent.

package/dist/types/runtime/infra/background-tasks.d.ts

@@ -38,6 +38,17 @@ export interface StartAgentTaskOptions {
     depth: number;
     maxTurns: number;
     parentTaskId?: string;
+    /** Session that launched this task (LH-10: an explicit cancel propagates to the
+     * background work that session spawned). Keyed by session — turn ids don't
+     * cross the client/agent boundary, session ids do. */
+    launchSessionId?: string;
+    /**
+     * Idle (no-progress) reclaim window (ms): the task is force-failed as `timeout`
+     * only after `idleMs` with no progress signal — an actively-producing task is
+     * never reclaimed (LH-6). Defaults to DEFAULT_FORKED_AGENT_IDLE_MS; pass
+     * Infinity / <= 0 to disable.
+     */
+    idleMs?: number;
     /** The actual work. Receives the task's own abort signal and task id. */
     run(signal: AbortSignal, taskId: string): Promise<AgentRunOutcome>;
 }
@@ -68,11 +79,23 @@ export interface ExternalTaskControl {
 }
 export declare class BackgroundTaskManager {
     private readonly store;
+    /** LH-10: resolves the active session id for tasks registered without an
+     *  explicit launchSessionId (e.g. a backgrounded shell from a sub-agent's
+     *  exec) so an explicit cancel can still reach them. */
+    private readonly getCurrentSessionId?;
     private readonly controllers;
     private readonly bashHandles;
     private readonly externalControls;
+    private readonly deadlineTimers;
+    /** LH-6: last liveness signal + window per task — drives idle (no-progress) reclaim. */
+    private readonly lastProgressAt;
+    private readonly idleReclaimMs;
     private readonly settledListeners;
-    constructor(store: TaskStore);
+    constructor(store: TaskStore, 
+    /** LH-10: resolves the active session id for tasks registered without an
+     *  explicit launchSessionId (e.g. a backgrounded shell from a sub-agent's
+     *  exec) so an explicit cancel can still reach them. */
+    getCurrentSessionId?: (() => string | undefined) | undefined);
     /** Subscribe to natural task settlement (completed/failed). Returns unregister fn. */
     onTaskSettled(listener: (task: TaskState) => void): () => void;
     private fireSettled;
@@ -108,8 +131,44 @@ export declare class BackgroundTaskManager {
      */
     readOutput(taskId: string): Promise<TaskOutputSnapshot | null>;
     /**
-     * Cancel a running task: kills the shell process / aborts the agent,
-     * then marks the task cancelled. Returns false if not found or already terminal.
+     * Kill/abort whichever executor backs a task (bash handle, forked-agent abort
+     * controller, or external control) and drop its registry entry. Shared by
+     * cancelTask (user/turn cancel) and enforceTimeout (deadline).
+     */
+    private teardownExecutors;
+    /**
+     * Arm an idle (no-progress) reclaim window for a task (LH-6). The task is only
+     * force-failed as `timeout` after it goes fully silent — no output, no tool
+     * activity, no progress signal — for `idleMs`. A task that keeps producing is
+     * kept alive INDEFINITELY (markProgress resets the window), so a slow-but-working
+     * fork (deep research, a large build) is never killed; only a leaked runner
+     * promise, a dead subprocess, or a stuck-with-no-output loop is reclaimed. This
+     * is what distinguishes a dead task from a slow one — a fixed absolute deadline
+     * cannot. No-op for non-positive / non-finite windows.
+     */
+    private armIdleReclaim;
+    /**
+     * Record a liveness signal (a subagent event, output growth, etc.). Pushes the
+     * idle reclaim window forward so an actively-working task is never reclaimed.
+     * O(1) — only stamps the time; the timer re-checks the elapsed idle on expiry.
+     */
+    markProgress(taskId: string): void;
+    private scheduleIdleCheck;
+    private onIdleCheck;
+    private clearDeadline;
+    private enforceIdleTimeout;
+    /**
+     * Cancel a running task: kills the shell process / aborts the agent, then marks
+     * the task cancelled. Returns false if not found or already terminal.
      */
     cancelTask(taskId: string): boolean;
+    /**
+     * Cancel every still-running task launched by `sessionId` (LH-10). An explicit
+     * user cancel propagates to the background work that session spawned — unlike a
+     * superseded-turn abort or a natural turn-end, which leave background tasks
+     * running. Returns the ids actually cancelled.
+     */
+    cancelTasksForSession(sessionId: string): string[];
+    /** Cancel every non-terminal task (session teardown). Returns cancelled ids. */
+    cancelAllRunning(): string[];
 }

package/dist/types/runtime/infra/llmrouter-catalog.d.ts

@@ -9,6 +9,16 @@ interface CatalogFetchOptions {
 export declare class LlmrouterCatalogUnavailableError extends Error {
     constructor(message?: string);
 }
+/**
+ * Raised when the llmrouter published endpoint (/v1/models) rejects the inference key with an
+ * auth failure (401/403). This is a PERSISTENT condition (revoked/expired/inactive key), unlike a
+ * transient network blip — so callers must NOT fall back to the full routable catalog (that would
+ * advertise 600+ models the dead key cannot actually call). Surface "please re-authenticate" instead.
+ */
+export declare class LlmrouterAuthError extends Error {
+    readonly status: number;
+    constructor(status: number, message?: string);
+}
 export interface LlmrouterCatalogProvider {
     id: string;
     name?: string;

package/dist/types/runtime/prompt/environment-context.d.ts

@@ -35,6 +35,11 @@ export declare function createTaskGuidanceSection(domain?: TaskDomain): SystemPr
  * Tells the LLM when to use specialized tools vs. primitives.
  */
 export declare function createToolGuidanceSection(): SystemPromptSection;
+type DeferredIndexEntry = {
+    name: string;
+    description: string;
+    searchHint?: string;
+};
 /**
  * Render the deferred-tool listing with accuracy-aware token discipline.
  *
@@ -48,10 +53,7 @@ export declare function createToolGuidanceSection(): SystemPromptSection;
  *     details on demand).
  * Names are ALWAYS listed so any capability can be `select:`ed directly.
  */
-export declare function buildDeferredToolIndexBody(deferred: Array<{
-    name: string;
-    description: string;
-}>, richHintLimit: number): string[];
+export declare function buildDeferredToolIndexBody(deferred: DeferredIndexEntry[], richHintLimit: number): string[];
 /**
  * Index of deferred tools so the model KNOWS these capabilities exist even
  * though their schemas are not loaded. Without this the model sees only the
@@ -61,10 +63,7 @@ export declare function buildDeferredToolIndexBody(deferred: Array<{
  * dynamic registrations (MCP, session bootstrap) land; the rendered text is
  * stable across turns otherwise, so prompt cache is preserved in practice.
  */
-export declare function createDeferredToolIndexSection(listDeferredTools: () => Array<{
-    name: string;
-    description: string;
-}>, options?: {
+export declare function createDeferredToolIndexSection(listDeferredTools: () => DeferredIndexEntry[], options?: {
     richHintLimit?: number;
 }): SystemPromptSection;
 /**
@@ -88,3 +87,4 @@ export declare function createLanguageSection(language?: string): SystemPromptSe
  * fallback handle English/other, which weak models already mirror fine).
  */
 export declare function detectResponseLanguage(userText: string): string | undefined;
+export {};

package/dist/types/runtime/tasks/task-types.d.ts

@@ -65,6 +65,11 @@ export interface TaskStateBase {
     lifecycle: TaskLifecycle;
     /** Parent task ID (for nested sub-agents). */
     parentTaskId?: string;
+    /** Session that launched this task — lets an explicit cancel propagate to the
+     * background work that session spawned (LH-10). Keyed by session, not turn:
+     * the client and agent mint turn ids in separate namespaces (they never match),
+     * but the session id is shared across the boundary. */
+    launchSessionId?: string;
     /** Execution depth (0 = root). */
     depth: number;
     /** Maximum turns before forced stop. */

package/dist/types/skills/tools/file-tool-arguments.d.ts

@@ -11,3 +11,18 @@ export declare function missingRequiredStringParam(params: Record<string, unknow
     allowEmpty?: boolean;
 }): string | null;
 export declare function invalidFileToolArguments(type: "read" | "write" | "edit", message: string): PortableToolResult;
+/**
+ * Turn a raw filesystem error (ENOENT/EISDIR/EACCES/…) into a structured, ACTIONABLE
+ * tool result. A bare "ENOENT: no such file or directory, open '…'" tells the model
+ * nothing it can act on; this names the path and the concrete recovery step, so the
+ * model self-corrects instead of thrashing. Shared by read/write/edit.
+ */
+export declare function fileSystemErrorResult(type: "read" | "write" | "edit", resolvedPath: string, error: unknown): PortableToolResult;
+/**
+ * LH-3: validate-before-write for structured artifacts. If `path` targets a
+ * `.json` file, its content MUST parse as JSON — otherwise a write/patch could
+ * persist a corrupt state file (continuity-checkpoint.json / document-index.json
+ * etc.) that the next reopen depends on, silently breaking reconstruction.
+ * Returns a human-readable error reason, or null when OK (or the path is not JSON).
+ */
+export declare function jsonWriteValidationError(path: string, content: string): string | null;

package/dist/types/skills/tools/shell/command-classification.d.ts

@@ -43,3 +43,10 @@ export declare function commandHasAnyCd(command: string): boolean;
  */
 export declare function classifyCommand(command: string): CommandClassification;
 export declare function requiresDedicatedReadSearchTool(classification: CommandClassification): boolean;
+/**
+ * Actionable, command-type-specific redirect for a blocked exec command. Spelling out the
+ * exact dedicated tool (read for file contents, search for content lookup) lets the model
+ * self-correct instead of retrying the same blocked command into a recovery stop. Only
+ * called for reads/searches now (directory listing is allowed via exec — see above).
+ */
+export declare function dedicatedToolRedirectMessage(classification: CommandClassification): string;

package/dist/types/skills/tools/shell/shell-exec.d.ts

@@ -4,7 +4,9 @@ import { type ProgressCallback } from "./task-output.js";
 import type { SandboxConfig } from "./sandbox/sandbox-types.js";
 export type { ExecResult } from "./shell-command.js";
 export declare function getCwd(): string;
-export declare function setCwd(path: string, relativeTo?: string): void;
+export declare function setCwd(path: string, relativeTo?: string, opts?: {
+    mustExist?: boolean;
+}): boolean;
 export declare function getOriginalCwd(): string;
 export declare function initCwd(cwd: string): void;
 export interface ExecOptions {

package/dist/types/skills/tools/tool-selection-eval.tasks.d.ts

@@ -0,0 +1,9 @@
+import type { ToolSearchCorpusEntry } from "./tool-search-tool.js";
+import type { ToolSelectionCase } from "./tool-selection-eval.js";
+export declare const TASK_CORPUS: ToolSearchCorpusEntry[];
+export declare const EN_CASES: ToolSelectionCase[];
+export declare const CN_CASES: ToolSelectionCase[];
+export declare const ALL_CASES: ToolSelectionCase[];
+export declare const HELDOUT_CASES: ToolSelectionCase[];
+export declare const NEGATIVE_CASES: ToolSelectionCase[];
+export declare const DECIRC_CASES: ToolSelectionCase[];

package/dist/types/skills/tools.d.ts

@@ -10,6 +10,15 @@ import type { PortableTool } from "./portable-tool.js";
 import type { ToolDefinition } from "../protocol/wire/index.js";
 import { AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, filterToolsForAgent } from "./tool-access.js";
 export { AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, filterToolsForAgent };
+/**
+ * Deferral policy (CC-aligned): a few HIGH-FREQUENCY capabilities stay LOADED even if their
+ * factory marks them deferrable, so the model never has to voluntarily tool_search for the
+ * things users ask for most. Only the long tail (rare media variants, niche tools) and MCP
+ * stay deferred. Trades a small always-on token cost on common paths for discovery
+ * reliability — mirrors Claude Code (keeps common tools loaded; defers only the long
+ * tail / large MCP sets) rather than relying on the model to decide to search.
+ */
+export declare const COMMON_LOADED_CAPABILITIES: Set<string>;
 export declare class ToolRegistry {
     private readonly toolPool;
     private readonly activatedTools;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "2.16.2",
+  "version": "2.16.4",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",
@@ -91,7 +91,7 @@
     "@agentclientprotocol/sdk": "^0.25.0",
     "@napi-rs/canvas": "0.1.100",
     "@xiaozhiclaw/pet-core": "0.1.2",
-    "@xiaozhiclaw/provider-core": "^0.1.19",
+    "@xiaozhiclaw/provider-core": "^0.1.20",
     "better-sqlite3": "^12.10.0",
     "dotenv": "^17.3.1",
     "ioredis": "^5.11.1",