qlogicagent 2.10.33 → 2.10.34

package/dist/types/orchestration/tool-cascade.d.ts

@@ -23,18 +23,27 @@
  *
  * ```ts
  * import { cascadeWebSearch } from "./tool-cascade.js";
- * import { ZhipuToolAPI } from "@xiaozhiclaw/provider-core/transports/zhipu-tool-api";
+ * const providerApi = host.resolveProviderToolApi();
  *
  * const providerApi = new ZhipuToolAPI({ baseUrl, apiKey });
  * const cascadedSearch = cascadeWebSearch(providerApi, fallbackSearchFn);
  * const tool = createWebSearchTool({ search: cascadedSearch });
  * ```
  */
-import type { ProviderToolAPI } from "@xiaozhiclaw/provider-core";
 import type { WebSearchBackend } from "../runtime/ports/web-search-contracts.js";
+export interface ProviderToolApiPort {
+    capabilities: readonly string[];
+    webSearch?(query: string, options?: {
+        maxResults?: number;
+    }): Promise<Array<{
+        title: string;
+        url: string;
+        snippet: string;
+    }>>;
+}
 /**
  * Cascade web search: provider-native search → host fallback.
  * Returns a WebSearchToolDeps.search function that tries the provider's
  * webSearch API first, falling back to the host's search on error.
  */
-export declare function cascadeWebSearch(providerApi: ProviderToolAPI | undefined, fallbackSearch: WebSearchBackend["search"]): WebSearchBackend["search"];
+export declare function cascadeWebSearch(providerApi: ProviderToolApiPort | undefined, fallbackSearch: WebSearchBackend["search"]): WebSearchBackend["search"];

package/dist/types/orchestration/tool-loop/tool-schema.d.ts

@@ -2,6 +2,10 @@ import type { OpenAiToolCall } from "./conversation-repair.js";
 export type ToolSchemaProvider = {
     modelProvider?: string;
     modelId?: string;
+    cleanSchema?: (schema: Record<string, unknown>, context: {
+        modelProvider?: string;
+        modelId?: string;
+    }) => Record<string, unknown>;
 };
 export interface FunctionToolSource {
     name: string;
@@ -40,4 +44,3 @@ export declare function buildToolResultMessage(callId: string, result: {
     toolReferences?: string[];
     imageUrls?: string[];
 }): Record<string, unknown>;
-export declare function cleanToolSchemaForGemini(schema: Record<string, unknown>): unknown;

package/dist/types/orchestration/workflow/qla-executor-host.d.ts

@@ -7,7 +7,7 @@
  * callback. Tool invocation goes straight through the single-source-of-truth tool registry
  * (`findTool`). fail-loud everywhere: unknown tool, missing channel host, or any rejection throws.
  */
-import type { PortableTool } from "../../skills/portable-tool.js";
+import type { RuntimeToolContract } from "../../runtime/ports/index.js";
 import type { ExecutorHost } from "./node-schema.js";
 /** Injected boundary capabilities — supplied by the handler host that owns the real runners. */
 export interface QlaExecutorHostDeps {
@@ -34,8 +34,8 @@ export interface QlaExecutorHostDeps {
         payload: unknown;
         signal?: AbortSignal;
     }) => Promise<unknown>;
-    /** Tool lookup; defaults to the real registry. Injectable for tests. */
-    findTool?: (name: string) => PortableTool | undefined;
+    /** Tool lookup supplied by the runtime host. */
+    findTool: (name: string) => RuntimeToolContract | undefined;
     /** fetch impl; defaults to global fetch. Injectable for tests. */
     fetchImpl?: typeof fetch;
 }

package/dist/types/protocol/methods.d.ts

@@ -348,6 +348,28 @@ export interface CommunitySetConsentResult {
     consent: CommunityConsentView;
     warning?: string;
 }
+export interface CommunityMatchRegistryParams {
+    intent: string;
+    topK?: 1 | 2 | 3;
+    preferOfficial?: boolean;
+}
+export interface CommunityRegistryMatchResult {
+    id: string;
+    type: string;
+    title: string;
+    summary: string;
+    capabilityTags: string[];
+    sourceTier: CommunityInstallSourceTier;
+    trustStage: CommunityInstallTrustStage;
+    resourceRiskTier: CommunityInstallRiskTier;
+    effectiveRiskTier: CommunityInstallRiskTier;
+    latestVersion: string | null;
+    canonical: true;
+}
+export interface CommunityMatchRegistryResult {
+    ok: boolean;
+    matches: CommunityRegistryMatchResult[];
+}
 export interface CommunitySharedResource {
     id: string;
     type: string;
@@ -539,7 +561,7 @@ export interface AgentAbortResult {
 }
 export interface ToolApprovalResponseParams {
     approvalId: string;
-    decision: "allow-once" | "allow-session" | "allow-always" | "deny";
+    decision: "allow" | "deny";
     toolName?: string;
     updatedInput?: Record<string, unknown>;
     permissionUpdate?: {
@@ -729,6 +751,10 @@ export interface RpcMethodMap {
         params: CommunitySetConsentParams;
         result: CommunitySetConsentResult;
     };
+    "community.matchRegistry": {
+        params: CommunityMatchRegistryParams;
+        result: CommunityMatchRegistryResult;
+    };
     "community.listShared": {
         params: undefined;
         result: CommunityListSharedResult;

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

@@ -354,8 +354,6 @@ export interface AcpPermissionRequestParams {
 export interface AcpPermissionOption {
     id: string;
     label: string;
-    /** Whether this option grants persistent permission */
-    persistent?: boolean;
 }
 export interface AcpPermissionRequestResult {
     optionId: string;

package/dist/types/protocol/wire/agent-rpc.d.ts

@@ -87,7 +87,7 @@ export interface ToolApprovalRequestParams {
     arguments: string;
     /** Human-readable reason for requiring approval. */
     message?: string;
-    /** Suggested actions the user can pick (allow-once, allow-always, deny). */
+    /** Suggested allow/ask/deny policy updates the user can apply with the decision. */
     suggestions?: string[];
 }
 /**
@@ -98,12 +98,12 @@ export interface ToolApprovalResponseParams {
     /** Must match the `approvalId` from the request. */
     approvalId: string;
     /** User's decision. */
-    decision: "allow-once" | "allow-session" | "allow-always" | "deny";
-    /** Optional tool name, used to create a persistent rule for allow-always. */
+    decision: "allow" | "deny";
+    /** Optional tool name for host display or audit context. */
     toolName?: string;
     /** Optional corrected tool input after user review. */
     updatedInput?: Record<string, unknown>;
-    /** Optional persistent rule update to save after approval. */
+    /** Optional rule update to save after an allow decision. Scope is metadata, not a decision value. */
     permissionUpdate?: {
         pattern: string;
         behavior: "allow" | "ask" | "deny";

package/dist/types/protocol/wire/capability-manifest.d.ts

@@ -1,4 +1,4 @@
-import type { WebActionScope, WebApprovalDefault, WebCapabilityDescriptorContract, WebCapabilityFamily, WebCapabilityId, WebDegradationTarget, WebEscalationReason, WebExecutionMode, WebPolicyRiskClass, WebRetryPolicy, WebStatefulness, WebTaskMode } from "./web-capability.js";
+import type { WebActionScope, WebApprovalDefault, WebCapabilityDescriptorContract, WebCapabilityFamily, WebCapabilityId, WebDegradationTarget, WebEscalationReason, WebExecutionMode, WebPolicyRiskClass, WebRetryPolicy, WebStatefulness, WebTaskMode, ToolRiskLevel } from "./web-capability.js";
 import type { ApprovalRequiredToolContract } from "./session.js";
 export declare const CAPABILITY_MANIFEST_DIFF_SECTIONS: readonly ["gatewayVersion", "toolNamespaces", "workspaceIds", "installedCapabilities", "enabledCapabilities", "features", "approvalMode", "toolManifests", "skillManifests", "pluginManifests", "mcpManifests", "approvalPolicy", "workspaceSummaries"];
 export type CapabilityManifestDiffSection = (typeof CAPABILITY_MANIFEST_DIFF_SECTIONS)[number];
@@ -15,6 +15,7 @@ export type CapabilityToolManifestContract = WebCapabilityDescriptorContract & {
     statefulness?: WebStatefulness;
     approvalDefault?: WebApprovalDefault;
     policyRiskClass?: WebPolicyRiskClass;
+    riskLevel?: ToolRiskLevel;
     allowedActionScopes?: WebActionScope[];
     degradationTarget?: WebDegradationTarget;
     upgradeTargets?: WebCapabilityId[];

package/dist/types/protocol/wire/capability-transport.d.ts

@@ -1,6 +1,6 @@
 import type { ProxyKeySource } from "./transport.js";
 import type { MemoryContextBlock } from "./memory-provider-lifecycle.js";
-import type { WebCapabilityFamily, WebTaskMode, WebExecutionMode, WebStatefulness, WebPolicyRiskClass } from "./web-capability.js";
+import type { WebCapabilityFamily, WebTaskMode, WebExecutionMode, WebStatefulness, WebPolicyRiskClass, ToolRiskLevel } from "./web-capability.js";
 export interface TransportCapabilitySummaryContract {
     snapshotVersion: string;
     installedCapabilities: string[];
@@ -97,7 +97,7 @@ export interface CapabilityToolManifestEntry {
     defaultProfiles?: string[];
     requiredParameters?: string[];
     parametersSummary?: string;
-    riskLevel?: "low" | "medium" | "high";
+    riskLevel?: ToolRiskLevel;
     approvalMode?: "user-confirm" | "pre-authorized";
     requiresApproval?: boolean;
     parallelSafe?: boolean;

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

@@ -4,6 +4,8 @@
  * These types appear in RPC method params/results (thread.turn, session.resume, etc.)
  * and are needed by every consumer that interacts with the agent.
  */
+import type { ToolRiskLevel } from "./web-capability.js";
+export type { ToolRiskLevel } from "./web-capability.js";
 export type ChatMessageRole = "system" | "user" | "assistant" | "tool";
 /** Thinking block from Anthropic Messages API (DeepSeek, Claude, etc.) */
 export interface ThinkingBlock {
@@ -86,6 +88,8 @@ export interface ToolDefinition {
         displayDescription?: LocalizedToolText;
         serialOnly?: boolean;
         parallelSafe?: boolean;
+        /** Unified permission risk class. */
+        riskLevel?: ToolRiskLevel;
         /** If true, host should request user approval before execution. */
         requiresApproval?: boolean;
         /** Tool is read-only / safe — skip approval even in strict mode. */

package/dist/types/protocol/wire/index.d.ts

@@ -10,7 +10,7 @@ export { ACP_EXTENDED_METHODS, ACP_EXTENDED_SESSION_UPDATE_TYPES, ACP_METHODS, A
 export { type ApprovalRequiredToolContract, type ModelSelectionReason, type PendingPromptContract, type RuntimeCapabilitySummaryContract, type RuntimeSessionContract, type SessionIdentityContract, } from "./session.js";
 export { type GatewayChannelExecutionEgressContract, type GatewayChannelExecutionEgressKind, type GatewayChannelExecutionIngressBindingContract, type GatewayChannelExecutionIngressSource, } from "./channel-ingress.js";
 export { CAPABILITY_MANIFEST_DIFF_SECTIONS, cloneCapabilityManifestSnapshot, createCapabilityManifestDiffPayload, deriveCapabilityToolNamespaces, deriveCapabilityWorkspaceIds, mergeCapabilityManifestSnapshot, type CapabilityManifestApprovalMode, type CapabilityManifestApprovalPolicyContract, type CapabilityManifestDiffSection, type CapabilityMcpManifestContract, type CapabilityManifestSnapshotContract, type HostCapabilitySnapshotContract, type CapabilityPluginManifestContract, type RuntimeCapabilityViewContract, type RuntimeToolEligibilityContract, type CapabilitySkillManifestContract, type CapabilityToolManifestContract, type CapabilityWorkspaceSummaryContract, type ToolEligibilityResolvedSource, type ToolEligibilityReasonCode, type ToolEligibilityStatus, } from "./capability-manifest.js";
-export { WEB_ACTION_SCOPE_VALUES, WEB_APPROVAL_DEFAULT_VALUES, WEB_CAPABILITY_FAMILY_VALUES, WEB_CAPABILITY_ID_VALUES, WEB_DEGRADATION_TARGET_VALUES, WEB_ESCALATION_REASON_VALUES, WEB_EXECUTION_MODE_VALUES, WEB_POLICY_RISK_CLASS_VALUES, WEB_RETRY_POLICY_VALUES, WEB_STATEFULNESS_VALUES, WEB_TASK_MODE_VALUES, type WebActionScope, type WebApprovalDefault, type WebCapabilityDescriptorContract, type WebCapabilityFamily, type WebCapabilityId, type WebDegradationTarget, type WebEscalationReason, type WebExecutionMode, type WebPolicyRiskClass, type WebRetryPolicy, type WebStatefulness, type WebTaskMode, } from "./web-capability.js";
+export { WEB_ACTION_SCOPE_VALUES, WEB_APPROVAL_DEFAULT_VALUES, WEB_CAPABILITY_FAMILY_VALUES, WEB_CAPABILITY_ID_VALUES, WEB_DEGRADATION_TARGET_VALUES, WEB_ESCALATION_REASON_VALUES, WEB_EXECUTION_MODE_VALUES, WEB_POLICY_RISK_CLASS_VALUES, WEB_RETRY_POLICY_VALUES, WEB_STATEFULNESS_VALUES, WEB_TASK_MODE_VALUES, type WebActionScope, type WebApprovalDefault, type WebCapabilityDescriptorContract, type WebCapabilityFamily, type WebCapabilityId, type WebDegradationTarget, type WebEscalationReason, type WebExecutionMode, type WebPolicyRiskClass, type WebRetryPolicy, type WebStatefulness, type WebTaskMode, type ToolRiskLevel, } from "./web-capability.js";
 export { MEMORY_OBSERVATION_HOOK_VALUES, MEMORY_OBSERVATION_SOURCE_VALUES, MEMORY_WRITE_ACCESS_VALUES, type MemoryContextBlock, type MemoryIngestMessage, type MemoryIngestOptions, type MemoryLlmConfig, type MemoryObservedMsg, type MemoryObservedPayload, type MemoryObservationEnvelope, type MemoryObservationHook, type MemoryObservationSource, type MemoryObserveRequestMsg, type MemoryProvider, type MemorySearchOptions, type MemorySearchResult, type MemoryWriteAccess, } from "./memory-provider-lifecycle.js";
 export { RESOURCE_MANIFEST_SCHEMA_VERSION, RUNTIME_ASSET_IDS, RUNTIME_PROFILE_IDS, createDefaultRuntimeResourceProfiles, getManifestShortcutEntry, getRuntimeResourceAsset, getRuntimeResourceProfile, getRuntimeResourceProfileAssets, normalizeRuntimeResourceManifest, upsertRuntimeResourceAsset, type RuntimeManifestShortcutEntry, type RuntimeResourceArtifact, type RuntimeResourceAsset, type RuntimeResourceAssetDelivery, type RuntimeResourceAssetKind, type RuntimeResourceAssetMap, type RuntimeResourceManifest, type RuntimeResourcePlatform, type RuntimeResourceProfile, type RuntimeResourceProfileMap, } from "./resource-manifest.js";
 export { MUTATION_CHECKPOINT_ENTRY_KIND_VALUES, MUTATION_CHECKPOINT_BACKEND_VALUES, MUTATION_CHECKPOINT_PHASE_VALUES, type MutationCheckpointBackend, type MutationCheckpointContract, type MutationCheckpointEntryKind, type MutationCheckpointPhase, type MutationCheckpointRestoreAckContract, type MutationCheckpointRollbackResultContract, type MutationCheckpointRestoreContract, type MutationCheckpointSnapshotEntryContract, } from "./checkpoint.js";

package/dist/types/protocol/wire/notification-payloads.d.ts

@@ -10,6 +10,7 @@
  * 2. Add entry in NotificationMethodMap here
  * 3. Add event name string in agent-events.ts (if WS-relayed)
  */
+import type { ToolRiskLevel } from "./web-capability.js";
 /** Identifies which agent produced this notification (main or teammate). */
 export interface AgentSource {
     id: string;
@@ -630,7 +631,7 @@ export interface PetConfirmNotification {
     confirmId: string;
     toolName: string;
     description: string;
-    risk: "low" | "medium" | "high";
+    risk: ToolRiskLevel;
     timeoutMs?: number;
 }
 export interface PetForgedNotification {

package/dist/types/protocol/wire/web-capability.d.ts

@@ -12,6 +12,8 @@ export declare const WEB_APPROVAL_DEFAULT_VALUES: readonly ["required", "conditi
 export type WebApprovalDefault = (typeof WEB_APPROVAL_DEFAULT_VALUES)[number];
 export declare const WEB_POLICY_RISK_CLASS_VALUES: readonly ["browser-read", "browser-authenticated-read", "browser-state-changing"];
 export type WebPolicyRiskClass = (typeof WEB_POLICY_RISK_CLASS_VALUES)[number];
+export declare const TOOL_RISK_LEVEL_VALUES: readonly ["read", "write", "system", "external_egress"];
+export type ToolRiskLevel = (typeof TOOL_RISK_LEVEL_VALUES)[number];
 export declare const WEB_ACTION_SCOPE_VALUES: readonly ["read-page", "read-authenticated-page", "fill-form", "submit-form", "download-file", "reuse-session"];
 export type WebActionScope = (typeof WEB_ACTION_SCOPE_VALUES)[number];
 export declare const WEB_DEGRADATION_TARGET_VALUES: readonly ["web_search", "web_fetch", "deep_research", "blocked"];
@@ -28,6 +30,7 @@ export interface WebCapabilityDescriptorContract {
     statefulness?: WebStatefulness;
     approvalDefault?: WebApprovalDefault;
     policyRiskClass?: WebPolicyRiskClass;
+    riskLevel?: ToolRiskLevel;
     requiresRuntimeBackend?: boolean;
     requiresHostBridge?: boolean;
     supportsRenderBackend?: boolean;

package/dist/types/runtime/community/community-consent-client.d.ts

@@ -1,3 +1,4 @@
+import type { ConfigPort } from "../ports/index.js";
 import type { CommunityTelemetryEvent } from "./community-telemetry-types.js";
 export interface CommunityConsentView {
     enabled: boolean;
@@ -15,6 +16,7 @@ export interface SetCommunityConsentInput {
 export interface CommunityConsentClient {
     getConsent(): Promise<CommunityConsentView>;
     setConsent(input: SetCommunityConsentInput): Promise<CommunityConsentView>;
+    matchRegistry(input: CommunityRegistryMatchInput): Promise<CommunityRegistryMatchResult[]>;
     publishSkill(input: CommunityPublishSkillInput): Promise<CommunityPublishSkillResult>;
     recordSignal(input: CommunityRecordSignalInput): Promise<CommunityRecordSignalResult>;
     recordTelemetry(input: CommunityRecordTelemetryInput): Promise<CommunityRecordTelemetryResult>;
@@ -40,6 +42,24 @@ export interface CommunityPublishedVersion {
     checksum: string;
     sizeBytes: number;
 }
+export interface CommunityRegistryMatchInput {
+    intent: string;
+    topK?: number;
+    preferOfficial?: boolean;
+}
+export interface CommunityRegistryMatchResult {
+    id: string;
+    type: string;
+    title: string;
+    summary: string;
+    capabilityTags: string[];
+    sourceTier: CommunityInstallSourceTier;
+    trustStage: CommunityInstallTrustStage;
+    resourceRiskTier: CommunityInstallRiskTier;
+    effectiveRiskTier: CommunityInstallRiskTier;
+    latestVersion: string | null;
+    canonical: true;
+}
 export interface CommunityPublishSkillInput {
     id: string;
     title: string;
@@ -113,5 +133,5 @@ export interface CommunityConsentClientOptions {
     fetchFn?: typeof fetch;
 }
 export declare function createCommunityConsentClient(options: CommunityConsentClientOptions): CommunityConsentClient;
-export declare function createDefaultCommunityConsentClient(): CommunityConsentClient | null;
+export declare function createDefaultCommunityConsentClient(configPort?: ConfigPort): CommunityConsentClient | null;
 export declare function normalizeCommunityConsent(value: unknown, remoteSynced: boolean): CommunityConsentView;

package/dist/types/runtime/execution/dream-agent.d.ts

@@ -12,7 +12,7 @@
  */
 import type { DreamTaskState, DreamTurn } from "../tasks/task-types.js";
 import type { ToolDefinition, ToolInvoker, AgentLogger, HookRegistry, ForkedAgentRunnerFactory } from "../ports/agent-execution-contracts.js";
-import type { LLMTransport } from "@xiaozhiclaw/provider-core";
+import type { LLMTransport } from "../ports/index.js";
 export interface DreamTriggerConfig {
     /** Minimum hours since last consolidation. Default: 24. */
     minHours: number;

package/dist/types/runtime/execution/forked-agent.d.ts

@@ -18,7 +18,7 @@
  * Reference: claude-code src/utils/forkedAgent.ts
  */
 import type { AgentLogger, ChatMessage, ToolDefinition, ToolInvoker, TokenUsage, TurnEvent, HookRegistry, ForkedAgentRunnerFactory } from "../ports/agent-execution-contracts.js";
-import type { LLMTransport } from "@xiaozhiclaw/provider-core";
+import type { LLMTransport } from "../ports/index.js";
 import type { AgentProgress } from "./progress-tracker.js";
 /**
  * Tool permission check function — CC canUseTool parity.

package/dist/types/runtime/execution/tool-eligibility.d.ts

@@ -1,59 +1,36 @@
 /**
  * Tool eligibility resolver for CLI subprocess mode.
  *
- * Ported from src/core/runtime/tool-eligibility.ts, replacing Hub's
- * StoredGatewayCapabilitySnapshot with CLI's ToolDefinition[] from agent.turn.
- *
- * Core decision logic preserved:
- *   - Policy blocked (explicit block list)
- *   - Approval required (meta.requiresApproval / meta.isDangerous)
- *   - Read-only / safe tools (meta.isReadOnly → skip approval even in strict)
- *   - All tools from Gateway manifest are considered enabled & reachable
- *     (Gateway only sends available tools)
- *
- * Zero imports from express/pg/ioredis/ws.
+ * This layer only gates whether a tool may be offered to the model at all.
+ * Permission prompts are handled by the permission rule engine.
  */
 import type { ToolDefinition } from "../ports/agent-execution-contracts.js";
-/**
- * Tool permission levels aligned with Claude Code's permission model:
- *
- *   Level 1 — always-allow:  isReadOnly tools (e.g. read_file, search)
- *   Level 2 — default-allow: normal tools with no risk markers
- *   Level 3 — notify:        isDangerous tools → emit tool_blocked warning but allow
- *   Level 4 — ask:           requiresApproval tools → hook can block, emit approval.requested
- *   Level 5 — never-allow:   explicitly blocked by policy
- */
-export type PermissionLevel = 1 | 2 | 3 | 4 | 5;
-export type ToolEligibilityStatus = "eligible" | "approval-required" | "blocked-by-policy" | "dangerous-notify";
-export type ToolEligibilityReasonCode = "policy_blocked" | "approval_required" | "dangerous_tool" | "always_allowed";
+import type { PermissionRiskLevel } from "../ports/permission-contracts.js";
+export type ToolEligibilityDecision = "allow" | "ask" | "deny";
+export type ToolEligibilityStatus = "eligible" | "approval-required" | "blocked-by-policy";
+export type ToolEligibilityReasonCode = "policy_blocked" | "requires_approval" | "risk_read" | "risk_write" | "risk_system" | "risk_external_egress";
 export interface ToolEligibilityEntry {
     toolName: string;
     status: ToolEligibilityStatus;
-    permissionLevel: PermissionLevel;
+    decision: ToolEligibilityDecision;
+    riskLevel: PermissionRiskLevel;
     approvalRequired: boolean;
     reasonCodes: ToolEligibilityReasonCode[];
 }
 export interface ToolEligibilityContext {
-    /** Explicitly blocked tool names (e.g. from config or policy) */
+    /** Explicitly blocked tool names from config or policy. */
     blockedToolNames?: string[];
-    /** Dangerous tool name patterns (regex strings) for pattern-based detection */
+    /** Tool name regexes treated as system risk when no manifest risk is present. */
     dangerousPatterns?: string[];
 }
 export interface ToolEligibilityResult {
-    /** Tools eligible for execution (includes approval-required ones) */
+    /** Tools eligible for execution, including ask-before-run tools. */
     eligibleTools: ToolDefinition[];
-    /** Tools blocked by policy (removed from LLM tool list) */
+    /** Tools blocked by policy and removed from the LLM tool list. */
     blockedTools: ToolEligibilityEntry[];
-    /** Tools needing approval before execution */
+    /** Tools needing approval before execution. */
     approvalRequiredTools: ToolEligibilityEntry[];
-    /** Full eligibility map by tool name */
+    /** Full eligibility map by tool name. */
     eligibilityByName: Map<string, ToolEligibilityEntry>;
 }
-/**
- * Resolve tool eligibility for a set of tools from agent.turn.
- *
- * Returns filtered tool lists and eligibility metadata.
- * Blocked tools are removed from the eligible list (not sent to LLM).
- * Approval-required tools remain in the list but flagged for hook interception.
- */
 export declare function resolveToolEligibility(tools: ToolDefinition[], context?: ToolEligibilityContext): ToolEligibilityResult;

package/dist/types/runtime/execution/tool-eligibility.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/runtime/hooks/context-compression.d.ts

@@ -1,7 +1,7 @@
 import { ContextEngineRegistry, type CompressibleMessage, type CompressionResult, type CompressionStrategy, type AsyncCompressionStrategy, type SummarizeFn } from "../context/context-compression-strategies.js";
 import type { HookRegistry } from "./hook-registry.js";
 import type { RuntimeLogger } from "./hook-registry.js";
-import type { LLMTransport } from "@xiaozhiclaw/provider-core";
+import type { LLMTransport } from "../ports/index.js";
 /** Rough token estimate: ~4 chars per token for mixed CJK/English. */
 export declare function estimateTokens(msg: CompressibleMessage): number;
 /** Estimate total tokens for a message array. */

package/dist/types/runtime/infra/agent-paths.d.ts

@@ -9,10 +9,6 @@
 export declare const AGENT_DOT_DIR = ".qlogicagent";
 /** `~/.qlogicagent/` (or QLOGICAGENT_HOME override) */
 export declare function getUserAgentHome(): string;
-/** Legacy pre-profile user settings path: `~/.qlogicagent/settings.json`. */
-export declare function getLegacyUserSettingsPath(): string;
-/** Legacy pre-profile local memory database path: `~/.qlogicagent/memory/memories.db`. */
-export declare function getLegacyMemoryDbPath(): string;
 export declare function resolveActiveOwnerUserId(): string;
 export declare function encodeOwnerProfileSegment(ownerUserId: string): string;
 export declare function getOwnerProfileDir(ownerUserId?: string): string;

package/dist/types/runtime/infra/default-path-service.d.ts

@@ -0,0 +1,32 @@
+import type { PathService } from "../ports/index.js";
+export interface DefaultPathServiceOptions {
+    getActiveProjectRoot?: () => string;
+    setActiveWorkdir?: (dir: string) => void;
+    resolveProjectDir?: (projectId?: string) => string | undefined;
+}
+export declare class DefaultPathService implements PathService {
+    private readonly options;
+    constructor(options?: DefaultPathServiceOptions);
+    getActiveProjectRoot(): string;
+    setActiveWorkdir(dir: string): void;
+    resolveProjectDir(projectId?: string): string | undefined;
+    resolveActiveOwnerUserId(): string;
+    getUserAgentHome(): string;
+    getOwnerProfileDir(ownerUserId?: string): string;
+    getProfileMemoryDir(ownerUserId?: string): string;
+    getUserSettingsPath(): string;
+    getUserSkillsDir(): string;
+    getUserPluginsDir(): string;
+    getUserMcpConfigPath(): string;
+    getUserPluginCacheDir(): string;
+    getUserMarketplaceConfigPath(): string;
+    getProjectAgentDir(projectRoot?: string): string;
+    getProjectSettingsPath(projectRoot?: string): string;
+    getProjectInstructionsPath(projectRoot?: string): string;
+    getProjectSkillsDir(projectRoot?: string): string;
+    getProjectRulesDir(projectRoot?: string): string;
+    getProjectSessionsRoot(projectRoot?: string): string;
+    getKnownProjectDirs(projectDirs: string[], excludeCwd?: string): string[];
+    getAllProjectSkillDirs(projectDirs: string[], excludeCwd?: string): string[];
+}
+export declare function getDefaultPathService(): PathService;

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

@@ -1,4 +1,5 @@
 import type { ModelEntry, ModelRegistry } from "./model-registry.js";
+import type { ConfigPort } from "../ports/index.js";
 export declare const LLMROUTER_CATALOG_UNAVAILABLE_MESSAGE = "\u65E0\u6CD5\u8FDE\u63A5 llmrouter \u6A21\u578B\u76EE\u5F55";
 export declare const LLMROUTER_PROVIDER_ID = "llmrouter";
 export declare const LLMROUTER_PROVIDER_NAME = "LLMRouter";
@@ -42,15 +43,15 @@ export interface LlmrouterCatalogModel {
     capabilities?: string[];
     pricing?: Record<string, unknown>;
 }
-export declare function getLlmrouterBaseUrl(): string;
+export declare function getLlmrouterBaseUrl(configPort?: ConfigPort): string;
 export declare function getLlmrouterModelsUrl(baseUrl: string): string;
-export declare function listLlmrouterCatalogProviders(): Promise<LlmrouterCatalogProvider[]>;
-export declare function listLlmrouterCatalogModels(): Promise<LlmrouterCatalogModel[]>;
+export declare function listLlmrouterCatalogProviders(configPort?: ConfigPort): Promise<LlmrouterCatalogProvider[]>;
+export declare function listLlmrouterCatalogModels(configPort?: ConfigPort): Promise<LlmrouterCatalogModel[]>;
 export declare function listLlmrouterModelsByApiKey(baseUrl: string, apiKey: string): Promise<LlmrouterCatalogModel[]>;
 export declare function providerDisplayName(provider: LlmrouterCatalogProvider): string;
 export declare function providerBaseUrl(provider: LlmrouterCatalogProvider): string | undefined;
-export declare function getLlmrouterCatalogProvider(providerId: string): Promise<LlmrouterCatalogProvider | null>;
-export declare function refreshRegistryFromLlmrouterCatalog(registry: ModelRegistry): Promise<ModelEntry[]>;
+export declare function getLlmrouterCatalogProvider(providerId: string, configPort?: ConfigPort): Promise<LlmrouterCatalogProvider | null>;
+export declare function refreshRegistryFromLlmrouterCatalog(registry: ModelRegistry, configPort?: ConfigPort): Promise<ModelEntry[]>;
 export declare function refreshRegistryFromLlmrouterApiKey(registry: ModelRegistry, options: {
     baseUrl: string;
     apiKey: string;

package/dist/types/runtime/infra/model-registry.d.ts

@@ -55,8 +55,7 @@ export interface ResolvedModel {
 export declare const ALL_PURPOSES: ModelPurpose[];
 export declare class ModelRegistry {
     private keyPool;
-    private coreProviderRegistry;
-    private providerVariantResolver;
+    private providerCatalog;
     private models;
     private modelEnabledOverrides;
     private bindings;

package/dist/types/runtime/infra/process-config-port.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigPort } from "../ports/index.js";
+export declare function createProcessConfigPort(env?: NodeJS.ProcessEnv): ConfigPort;

package/dist/types/runtime/infra/provider-catalog-adapter.d.ts

@@ -0,0 +1,48 @@
+import { type ProviderVariantCapability } from "@xiaozhiclaw/provider-core";
+export type RuntimeProviderVariantCapability = ProviderVariantCapability;
+export interface RuntimeProviderCatalogProvider {
+    id: string;
+    name: string;
+    transport: string;
+    baseUrl: string;
+    defaultModel?: string;
+    group?: string;
+}
+export interface RuntimeProviderCatalogModel {
+    id: string;
+    name: string;
+    aliases?: string[];
+    contextWindow?: number;
+    maxOutput?: number;
+    streamRequired?: boolean;
+    toolCall?: boolean;
+    reasoning?: boolean;
+    vision?: boolean;
+    mediaType?: string;
+    costInput?: number;
+    costOutput?: number;
+    costCacheRead?: number;
+    costCacheWrite?: number;
+    pricing?: Record<string, unknown>;
+}
+export interface RuntimeProviderVariantResolutionInput {
+    publicModel: string;
+    requestedProtocol?: "openai-chat" | "openai-responses" | "anthropic-messages" | "volcengine-responses";
+    capabilities: RuntimeProviderVariantCapability[];
+    purpose: string;
+    userPreference?: {
+        providerIds?: string[];
+    };
+}
+export interface RuntimeProviderVariantResolution {
+    provider: string;
+    nativeModelId: string;
+}
+export declare class ProviderCatalogAdapter {
+    private readonly registry;
+    private readonly resolver;
+    getProvider(providerId: string): RuntimeProviderCatalogProvider | undefined;
+    listProviders(): RuntimeProviderCatalogProvider[];
+    listModels(providerId: string): RuntimeProviderCatalogModel[];
+    resolveBest(input: RuntimeProviderVariantResolutionInput): RuntimeProviderVariantResolution | undefined;
+}

package/dist/types/runtime/infra/token-budget.d.ts

@@ -5,7 +5,7 @@
  *   1. Per-task token budget (from TaskStateBase.tokenBudget)
  *   2. Session-level aggregate budget (all tasks combined)
  *   3. Budget continuation messages (CC tokenBudget.ts pattern)
- *   4. Graceful degradation (warn 鈫?force-stop, never hard-crash)
+ *   4. Graceful degradation (warn -> force-stop, never hard-crash)
  *
  * CC reference: utils/tokenBudget.ts, main.tsxmax-budget-usd /task-budget
  *

package/dist/types/runtime/ports/agent-runtime-ports.d.ts

@@ -0,0 +1,76 @@
+import type { HookRegistry } from "../../contracts/hooks.js";
+import type { OpenAiToolCall } from "./tool-call-contracts.js";
+import type { AgentLogger, ToolDefinition, ToolInvoker } from "./agent-execution-contracts.js";
+export interface RecallCategoryHint {
+    preferred: string[];
+    deprioritized: string[];
+}
+export interface RuntimeCompressibleMessage {
+    role: string;
+    content?: string | unknown;
+}
+export interface RuntimeCompressionResult {
+    messages: RuntimeCompressibleMessage[];
+    droppedCount: number;
+    tokensFreed?: number;
+    strategy: string;
+}
+export interface ToolExecutionResultPort {
+    callId: string;
+    toolName: string;
+    ok: boolean;
+    error?: string;
+    blocked?: boolean;
+    blockReason?: string;
+    durationMs?: number;
+    details?: Record<string, unknown>;
+    message: unknown;
+}
+export interface StreamingToolExecutorPort {
+    addTool(toolCall: OpenAiToolCall): void;
+    getRemainingResults(): AsyncIterable<ToolExecutionResultPort>;
+}
+export interface StreamingToolExecutorPortConfig {
+    toolInvoker: ToolInvoker;
+    hooks?: HookRegistry;
+    sessionId: string;
+    turnId: string;
+    log: AgentLogger;
+    signal?: AbortSignal;
+    maxConcurrentTools?: number;
+}
+export interface ContextCompressionEnginePort {
+    compressAsync(messages: RuntimeCompressibleMessage[], budget: number, context: {
+        model: string;
+        sessionId: string;
+    }): Promise<RuntimeCompressionResult>;
+}
+export interface ToolLoopRuntimePorts {
+    createContentReplacementState(): unknown;
+    enforceToolResultBudget(messages: Array<{
+        role: string;
+        content?: string | unknown;
+        tool_call_id?: string;
+    }>, state: unknown, sessionId: string): Promise<{
+        messages: unknown[];
+        newlyReplacedCount: number;
+    }>;
+    getActiveContextCompressionEngine(): ContextCompressionEnginePort | null;
+    compressMessages(messages: RuntimeCompressibleMessage[], options: {
+        budget: number;
+        model: string;
+    }): RuntimeCompressionResult;
+    getBudgetContinuationMessage(usagePct: number, totalUsed: number, tokenBudget: number): string;
+    createStreamingToolExecutor(config: StreamingToolExecutorPortConfig): StreamingToolExecutorPort;
+    resolveToolEligibility(tools: ToolDefinition[], context: unknown): {
+        eligibleTools: ToolDefinition[];
+        blockedTools: Array<{
+            toolName: string;
+        }>;
+    };
+}
+export interface AgentRuntimePorts {
+    toolLoop: ToolLoopRuntimePorts;
+    detectRecallCategories(query: string): RecallCategoryHint;
+    resolveModelForPurpose(purpose: "smallModel" | string): string | null;
+}

package/dist/types/runtime/ports/config-port.d.ts

@@ -0,0 +1,4 @@
+export interface ConfigPort {
+    get(key: string): string | undefined;
+}
+export declare function createRecordConfigPort(values: Record<string, string | undefined>): ConfigPort;