qlogicagent 2.10.33 → 2.10.35

package/dist/types/cli/pet-confirm-coordinator.d.ts

@@ -1,5 +1,5 @@
 import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
-import type { ApprovalResponse } from "../runtime/ports/index.js";
+import type { ApprovalResponse, PermissionRiskLevel } from "../runtime/ports/index.js";
 export interface PetConfirmPermissionResolver {
     resolveApproval(response: ApprovalResponse): void;
 }
@@ -15,6 +15,6 @@ export declare class PetConfirmCoordinator {
     private readonly deps;
     private readonly pendingConfirms;
     constructor(deps: PetConfirmCoordinatorDeps);
-    requestConfirm(toolName: string, description: string, risk: "low" | "medium" | "high", timeoutMs?: number): Promise<boolean>;
+    requestConfirm(toolName: string, description: string, risk: PermissionRiskLevel, timeoutMs?: number): Promise<boolean>;
     handleResponse({ confirmId, approved }: PetConfirmResponse): void;
 }

package/dist/types/cli/plugin-bootstrap.d.ts

@@ -0,0 +1,14 @@
+import type { HookRegistry } from "../contracts/hooks.js";
+import type { RuntimeLogger } from "../runtime/hooks/hook-registry.js";
+import type { PathService, ToolCatalog } from "../runtime/ports/index.js";
+import { PluginLoader } from "../skills/plugins/plugin-loader.js";
+export interface PluginBootstrapDeps {
+    config: Record<string, unknown>;
+    hooks: HookRegistry;
+    log: RuntimeLogger;
+    pathService: PathService;
+    toolCatalog: ToolCatalog;
+    setPluginLoader(loader: PluginLoader): void;
+}
+export declare const pluginToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<PluginBootstrapDeps>;
+export declare function configurePluginBootstrap(deps: PluginBootstrapDeps): void;

package/dist/types/cli/product-coordinator.d.ts

@@ -0,0 +1,25 @@
+import { ProductOrchestrator } from "../orchestration/agent-instance.js";
+import { ProductPlanner } from "../orchestration/product-planner.js";
+import { AgentProcessManager } from "../runtime/infra/agent-process.js";
+import type { AgentConfigStore } from "../runtime/infra/agent-config-store.js";
+import type { AcpDetector } from "../runtime/infra/acp-detector.js";
+export interface ProductCoordinatorHost {
+    acpDetector: AcpDetector;
+    agentConfigStore: AgentConfigStore | null;
+    productOrchestrator: ProductOrchestrator | null;
+    productPlanner: ProductPlanner | null;
+    productProcessManager: AgentProcessManager | null;
+    emitAgentStatus(agentId: string, state: string, extra?: {
+        missedBeats?: number;
+        lastActivityAt?: number;
+        usage?: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+        };
+    }): void;
+    handleMcpToolCall(memberId: string, tool: string, args: Record<string, unknown>): Promise<unknown>;
+    sendNotification(method: string, params: Record<string, unknown>): void;
+}
+export declare function ensureProductOrchestrator(host: ProductCoordinatorHost): ProductOrchestrator;
+export declare function ensureProductPlanner(host: ProductCoordinatorHost): ProductPlanner;

package/dist/types/cli/project-command-service.d.ts

@@ -0,0 +1,26 @@
+import type { ProjectInfo } from "../protocol/methods.js";
+import type { ProjectMemoryStore, ProjectMemoryStoreFactory } from "../runtime/ports/index.js";
+export interface ProjectCommandHost {
+    memdir: ProjectMemoryStore | null;
+    projectMemoryStoreFactory: ProjectMemoryStoreFactory;
+    mediaPersistence: {
+        setProjectDir(projectDir: string): void;
+    };
+    setActiveWorkdir(dir: string): void;
+}
+export interface ProjectCreateCommand {
+    name: string;
+    workspaceDir?: string;
+    type?: string;
+    groupId?: string;
+}
+export interface ProjectCreateResult {
+    project: ProjectInfo;
+    nameDuplicate?: ProjectInfo;
+    isAgentTeamProject: boolean;
+    deduplicated?: boolean;
+}
+type ProjectPlanStatus = NonNullable<ProjectInfo["planStatus"]>;
+export declare function isProjectPlanStatus(value: unknown): value is ProjectPlanStatus;
+export declare function createProject(host: ProjectCommandHost, command: ProjectCreateCommand): ProjectCreateResult;
+export {};

package/dist/types/cli/provider-core-facade.d.ts

@@ -25,3 +25,4 @@ export interface VolcengineFileTransport {
 }
 export declare function isVolcengineFileTransport(transport: unknown): transport is VolcengineFileTransport;
 export declare function createGeminiFileApi(): GeminiFileAPI;
+export declare function cleanGeminiToolSchema(schema: Record<string, unknown>): Record<string, unknown>;

package/dist/types/cli/runtime-hook-bootstrap.d.ts

@@ -2,7 +2,7 @@ import type { AgentLogger } from "../agent/types.js";
 import type { HookRegistry } from "../contracts/hooks.js";
 import { type MemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
 import type { TaskStore } from "../runtime/infra/task-runtime.js";
-import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, MemoryLearningSink, ProjectMemoryStore } from "../runtime/ports/index.js";
+import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, MemoryLearningSink, ProjectMemoryStore, ToolCatalog } from "../runtime/ports/index.js";
 import type { LLMTransport } from "./provider-core-facade.js";
 export interface RuntimeHookBootstrapDeps {
     log: AgentLogger;
@@ -10,6 +10,7 @@ export interface RuntimeHookBootstrapDeps {
     sessionId: string;
     projectRoot: string;
     memdir: ProjectMemoryStore;
+    toolCatalog: ToolCatalog;
     currentUserId: string;
     prefetchState: MemoryPrefetchState;
     getLastUserMessage(): string | undefined;

package/dist/types/cli/runtime-watcher-bootstrap.d.ts

@@ -1,12 +1,12 @@
 import type { AgentLogger } from "../agent/types.js";
 import type { HookRegistry } from "../contracts/hooks.js";
 import { type FileWatcher } from "../runtime/infra/file-watcher.js";
-import type { PermissionRuleEngine } from "../skills/permissions/rule-engine.js";
+import type { PermissionRuleEnginePort } from "../runtime/ports/index.js";
 export type { FileWatcher };
 export interface RuntimeWatcherBootstrapDeps {
     config: Record<string, unknown>;
     hooks: HookRegistry;
-    ruleEngine: PermissionRuleEngine;
+    ruleEngine: PermissionRuleEnginePort;
     sessionId: string;
     currentFileWatcher: FileWatcher | null;
     log: AgentLogger;

package/dist/types/cli/session-coordinator.d.ts

@@ -1,9 +1,11 @@
-import type { PathService } from "../runtime/ports/index.js";
+import type { PathService, ToolBootstrap } from "../runtime/ports/index.js";
 import type { MediaPersistence } from "../runtime/infra/media-persistence.js";
-export declare class CliPathService implements PathService {
+import { DefaultPathService } from "../runtime/infra/default-path-service.js";
+export declare class CliPathService extends DefaultPathService implements PathService {
     private readonly mediaPersistence;
+    private readonly toolBootstrap;
     private activeWorkdir;
-    constructor(mediaPersistence: MediaPersistence);
+    constructor(mediaPersistence: MediaPersistence, toolBootstrap: ToolBootstrap);
     getActiveProjectRoot(): string;
     setActiveWorkdir(dir: string): void;
     resolveProjectDir(projectId?: string): string | undefined;

package/dist/types/cli/session-query-service.d.ts

@@ -0,0 +1,23 @@
+import { SessionLocator } from "../runtime/session/session-locator.js";
+export interface SessionWorkspaceHost {
+    getActiveProjectRoot(): string;
+}
+export interface ThreadListItem {
+    id: string;
+    title?: string;
+    status: "active";
+    turnCount: number;
+    createdAt?: string;
+    lastActiveAt?: string;
+}
+export declare class SessionQueryService {
+    private readonly locator;
+    private readonly pathService;
+    constructor(locator?: SessionLocator, pathService?: import("../runtime/ports/path-service.js").PathService);
+    getActiveProjectId(): string;
+    getProjectWorkspaceDir(projectId: string): string;
+    resolveWorkspaceDir(sessionId: string, projectId?: string): string;
+    listThreads(limit: number, projectId?: string): Promise<ThreadListItem[]>;
+    resolveSessionWorkspaceDir(host: SessionWorkspaceHost, sessionId: string, projectId?: string): string;
+}
+export declare function safeSessionId(sessionId: string): string;

package/dist/types/cli/skill-meta-subturn-service.d.ts

@@ -0,0 +1,22 @@
+import type { TurnEvent, TurnRequest } from "../agent/types.js";
+import type { HookRegistry } from "../contracts/hooks.js";
+import type { ToolCatalog } from "../runtime/ports/index.js";
+import { type SkillLifecycleRecord } from "../skills/skill-system/skill-lifecycle.js";
+export interface SkillSubturnAgent {
+    run(request: TurnRequest, signal?: AbortSignal): AsyncGenerator<TurnEvent>;
+}
+export interface SkillSubturnHost {
+    getAgent(): SkillSubturnAgent | null;
+    getCurrentSessionId(): string;
+    getCurrentHooks(): HookRegistry | null;
+}
+export interface ExecuteSkillSubturnParams {
+    host: SkillSubturnHost;
+    toolCatalog: ToolCatalog;
+    skillName: string;
+    skillContent: string;
+    userArgs?: string;
+    signal?: AbortSignal;
+}
+export declare function executeSkillSubturn(params: ExecuteSkillSubturnParams): Promise<string>;
+export declare function resolveSkillSubagentTypeForLifecycle(skillName: string, record: SkillLifecycleRecord | undefined): string;

package/dist/types/cli/skill-meta-tool-bootstrap.d.ts

@@ -1,14 +1,13 @@
-import type { TurnEvent, TurnRequest } from "../agent/types.js";
 import type { HookRegistry } from "../contracts/hooks.js";
 import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
-import type { MemoryLearningSink } from "../runtime/ports/index.js";
+import type { MemoryLearningSink, PathService, ToolCatalog } from "../runtime/ports/index.js";
 import type { WorkspaceSkill } from "../skills/skill-system/skill-types.js";
-import type { SkillLifecycleRecord } from "../skills/skill-system/skill-lifecycle.js";
+import { type SkillSubturnAgent } from "./skill-meta-subturn-service.js";
+export { resolveSkillSubagentTypeForLifecycle } from "./skill-meta-subturn-service.js";
 export interface SkillMetaToolBootstrapDeps {
     config: Record<string, unknown>;
-}
-export interface SkillSubturnAgent {
-    run(request: TurnRequest, signal?: AbortSignal): AsyncGenerator<TurnEvent>;
+    pathService: PathService;
+    toolCatalog: ToolCatalog;
 }
 export type SkillLearningMemorySink = MemoryLearningSink;
 export interface SkillMetaToolHost {
@@ -21,5 +20,8 @@ export interface SkillMetaToolHost {
     getMemoryLearningSink(): SkillLearningMemorySink | null;
     getMemoryUserId(): string;
 }
+export interface SkillMetaToolRegistrationContext extends SkillMetaToolBootstrapDeps {
+    host: SkillMetaToolHost;
+}
+export declare const skillMetaToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<SkillMetaToolRegistrationContext>;
 export declare function configureSkillMetaToolBootstrap(host: SkillMetaToolHost, deps: SkillMetaToolBootstrapDeps): void;
-export declare function resolveSkillSubagentTypeForLifecycle(skillName: string, record: SkillLifecycleRecord | undefined): string;

package/dist/types/cli/skills-query-service.d.ts

@@ -0,0 +1,26 @@
+export interface SkillListEntry {
+    id: string;
+    name: string;
+    path: string;
+    active: boolean;
+    scope: "project" | "global";
+    category: "automation";
+    displayName: {
+        key: string;
+        fallback: string;
+    };
+    displayDescription: {
+        key: string;
+        fallback: string;
+    };
+    fallbackName: string;
+    fallbackDescription: string;
+    systemGenerated: boolean;
+    version?: string;
+    description?: string;
+}
+export declare function extractSkillMeta(skillMdPath: string): {
+    version?: string;
+    description?: string;
+};
+export declare function listSkillsForProject(projectRoot?: string): SkillListEntry[];

package/dist/types/cli/stdio-agent-session-bootstrap.d.ts

@@ -0,0 +1,78 @@
+import type { Agent } from "../agent/agent.js";
+import type { ToolInvoker } from "../agent/types.js";
+import type { HookRegistry } from "../contracts/hooks.js";
+import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
+import type { AcpPermissionRequestParams } from "../protocol/wire/index.js";
+import type { MemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
+import type { TaskStore } from "../runtime/infra/task-runtime.js";
+import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, PermissionMetadataResolver, PermissionRuleEnginePort, PathService, ProjectMemoryStore, ToolCatalog } from "../runtime/ports/index.js";
+import type { McpManager } from "../skills/mcp/mcp-manager.js";
+import type { PluginLoader } from "../skills/plugins/plugin-loader.js";
+import type { CliCoreToolHostDeps } from "./core-tool-coordinator.js";
+import { type CliAgentClient } from "./cli-agent-builder.js";
+import type { ResolvedTextGenerationConfig } from "./model-client-resolver.js";
+import type { LLMTransport, ProviderRegistry } from "./provider-core-facade.js";
+import type { MediaPersistence } from "../runtime/infra/media-persistence.js";
+import type { FileWatcher } from "./agent-runtime-bootstrap.js";
+export interface StdioAgentSessionBootstrapDeps {
+    config: Record<string, unknown> & {
+        maxRounds?: number;
+    };
+    resolvedTextConfig: ResolvedTextGenerationConfig;
+    verbose: boolean;
+    taskStore: TaskStore;
+    sessionId: string;
+    getTurnId(): string;
+    projectRoot: string;
+    pathService: PathService;
+    memdir: ProjectMemoryStore;
+    currentUserId: string;
+    memoryPrefetchState: MemoryPrefetchState;
+    getLastUserMessage(): string | undefined;
+    getLastAssistantMessage(): string | undefined;
+    resolveSmallModelClient(): {
+        transport: LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
+    providerRegistry: ProviderRegistry;
+    mediaPersistence: MediaPersistence;
+    toolCatalog: ToolCatalog;
+    runtimeSession: {
+        mcpManager: McpManager | null;
+        permissionUnregister: (() => void) | null;
+        fileWatcher: FileWatcher | null;
+        getPluginSkills(): ReturnType<PluginLoader["getPluginSkills"]>;
+        applyBootstrap(result: {
+            hooks: HookRegistry;
+            memoryHandlerProvider: MemoryHandlerProvider | null;
+            memoryDreamProvider: MemoryDreamRuntimeProvider | null;
+            memoryUserId: string;
+            permissionChecker: PermissionMetadataResolver;
+            permissionUnregister: () => void;
+            ruleEngine: PermissionRuleEnginePort;
+        }): void;
+    };
+    setMcpManager(manager: McpManager | null): void;
+    setMcpReady(ready: Promise<void>): void;
+    setPluginLoader(loader: PluginLoader): void;
+    setFileWatcher(watcher: FileWatcher | null): void;
+    getAgent(): Agent | null;
+    getAcpPermissionSession(): {
+        sessionId: string;
+        requestPermission(params: AcpPermissionRequestParams): Promise<{
+            optionId?: string;
+        }>;
+    } | undefined;
+    isPetActive(): boolean;
+    coreToolHost: CliCoreToolHostDeps;
+    log(message: string): void;
+    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
+}
+export interface StdioAgentSessionBootstrapResult {
+    agent: Agent;
+    agentClient: CliAgentClient;
+    toolInvoker: ToolInvoker;
+    hooks: HookRegistry;
+}
+export declare function bootstrapStdioAgentSession(deps: StdioAgentSessionBootstrapDeps): StdioAgentSessionBootstrapResult;

package/dist/types/cli/stdio-runtime-bootstrap.d.ts

@@ -0,0 +1,16 @@
+import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
+import type { ModelPurpose } from "../runtime/infra/model-registry.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+import { type StdioRuntimeServices } from "./stdio-runtime-services.js";
+export interface StdioRuntimeBootstrapDeps {
+    verbose: boolean;
+    getActiveProjectRoot(): string;
+    resolveClientForPurpose(purpose: ModelPurpose): {
+        transport: LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
+    log(message: string): void;
+    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
+}
+export declare function bootstrapStdioRuntimeServices(deps: StdioRuntimeBootstrapDeps): StdioRuntimeServices;

package/dist/types/cli/stdio-runtime-services.d.ts

@@ -0,0 +1,36 @@
+import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
+import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, PathService, ToolBootstrap, ToolCatalog } from "../runtime/ports/index.js";
+import { MediaPersistence } from "../runtime/infra/media-persistence.js";
+import { MediaClient, ProviderRegistry, type LLMTransport } from "./provider-core-facade.js";
+import { type MemoryProviderState } from "./memory-coordinator.js";
+import { type PetRuntime } from "./pet-runtime.js";
+import { type TurnMediaSetupHost } from "./turn-media-setup.js";
+export interface StdioRuntimeServicesDeps {
+    getActiveProjectRoot(): string;
+    resolveClientForPurpose(purpose: import("../runtime/infra/model-registry.js").ModelPurpose): {
+        transport: LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
+    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
+}
+export interface StdioRuntimeServices {
+    providerRegistry: ProviderRegistry;
+    mediaClient: MediaClient;
+    mediaPersistence: MediaPersistence;
+    pathService: PathService;
+    toolCatalog: ToolCatalog;
+    toolBootstrap: ToolBootstrap;
+    petRuntime: PetRuntime;
+    configureTurnMedia(params: {
+        host: Omit<TurnMediaSetupHost, "mediaClient">;
+        config?: Record<string, unknown>;
+        turnId: string;
+    }): void;
+    ensureMemoryProvider(currentUserId: string): MemoryProviderState;
+    closeMemoryProviders(state: {
+        memoryProvider: MemoryHandlerProvider | null;
+        memoryDreamProvider: MemoryDreamRuntimeProvider | null;
+    }): void;
+}
+export declare function createStdioRuntimeServices(deps: StdioRuntimeServicesDeps): StdioRuntimeServices;

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

@@ -26,18 +26,12 @@ export declare class StdioServer {
     private turnDone;
     private verbose;
     private transport;
-    private registry;
-    private mediaClient;
+    private readonly runtimeServices;
+    private readonly runtimeSession;
     private agent;
     private lastLlmConfigKey;
     private currentSessionId;
     private currentTurnId;
-    private currentHooks;
-    private mcpManager;
-    private mcpReady;
-    private pluginLoader;
-    private permissionChecker;
-    private permissionUnregister;
     /** Cached LLM transport for sub-agent forks (dream) */
     private currentTransport;
     private currentApiKey;
@@ -47,16 +41,8 @@ export declare class StdioServer {
     private sessionState;
     private currentMediaApiKeys;
     private taskStore;
-    /** Media auto-download service — persists generated media files locally. */
-    private mediaPersistence;
-    private pathService;
-    private toolCatalog;
     /** Session-scoped memory prefetch state (LRU dedup + byte limit). */
     private memoryPrefetchState;
-    /** Local SQLite memory provider (when better-sqlite3 is available). */
-    private memoryProvider;
-    private memoryDreamProvider;
-    private memoryUserId;
     /** Last user message text for auto-extract hook (set at turn start, cleared at turn end). */
     private lastUserMessageForAutoExtract;
     /** Last assistant message text for implicit extraction hook (set at turn end). */
@@ -65,7 +51,6 @@ export declare class StdioServer {
     private memdir;
     private readonly projectMemoryStoreFactory;
     /** Memory write gate state (P2+P3: category gate + supersedes). */
-    private fileWatcher;
     /** Pending ask_user requests waiting for host response */
     private pendingAskUser;
     /** Session-level task domain stickiness. Survives across turns within a session. */
@@ -76,9 +61,24 @@ export declare class StdioServer {
     private acpServer;
     private sessionHistory;
     private idleDreamCoordinator;
-    private petRuntime;
     private readonly petConfirmCoordinator;
     private modelRegistryHydration;
+    private get registry();
+    private get mediaClient();
+    private get mediaPersistence();
+    private get pathService();
+    get toolCatalog(): import("../runtime/ports/tool-contracts.js").ToolCatalog;
+    private get petRuntime();
+    private get currentHooks();
+    private get permissionChecker();
+    private set permissionChecker(value);
+    private set mcpManager(value);
+    private get memoryProvider();
+    private set memoryProvider(value);
+    private get memoryDreamProvider();
+    private set memoryDreamProvider(value);
+    private get memoryUserId();
+    private set memoryUserId(value);
     constructor(config: StdioServerConfig);
     /**
      * Get the active project workspace directory.
@@ -87,6 +87,7 @@ export declare class StdioServer {
     private getActiveProjectRoot;
     ensureModelRegistryHydrated(): Promise<void>;
     syncToolListMediaConfig(): void;
+    configureTurnMedia(config: Record<string, unknown> | undefined, turnId: string): void;
     /**
      * Single entry point for updating the active workdir.
      * Centralizes all side-effects (bootstrap workdir, media persistence, etc.).

package/dist/types/cli/test-support/tool-catalog-fixture.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeToolContract, ToolCatalog } from "../../runtime/ports/index.js";
+export declare function createToolCatalogFixture(initialTools?: RuntimeToolContract[]): ToolCatalog;
+export declare function createToolFixture(name: string, overrides?: Partial<RuntimeToolContract>): RuntimeToolContract;

package/dist/types/cli/tool-bootstrap-providers.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeToolContract, ToolBootstrapProvider, ToolBootstrapProviderContext, ToolRegistrationModuleKind } from "../runtime/ports/index.js";
+export declare function runToolBootstrapProviders(providers: readonly ToolBootstrapProvider[], context: ToolBootstrapProviderContext): RuntimeToolContract[];
+export declare function createToolBootstrapProvider(id: string, register: ToolBootstrapProvider["register"], kind?: ToolRegistrationModuleKind): ToolBootstrapProvider;

package/dist/types/cli/tool-bootstrap.d.ts

@@ -3,15 +3,10 @@ import { type TaskToolHooks } from "../skills/tools/task-tool.js";
 import { type ExecProgress } from "../skills/tools/exec-tool.js";
 import type { AgentLogger } from "../agent/types.js";
 import { type AskUserQuestion } from "../skills/tools/ask-user-tool.js";
-import { type MediaCapability, type MediaClient, type ProviderToolAPI } from "./provider-core-facade.js";
+import type { PathService, ToolCatalog } from "../runtime/ports/index.js";
+export { setMediaClientConfig, setProviderToolAPI } from "./media-runtime-facade.js";
 /** Enable or disable group security mode (blocks sensitive file access). */
 export declare function setGroupSecurityMode(enabled: boolean): void;
-/**
- * Set the provider's tool API for C-level cascade.
- * When set, web_search tool will try provider-native search first,
- * falling back to SearXNG. Called from stdio-server per session.
- */
-export declare function setProviderToolAPI(api: ProviderToolAPI | undefined): void;
 /** Set callback invoked after LLM-driven project switch. */
 export declare function setProjectSwitchCallback(cb: ((project: {
     id: string;
@@ -29,21 +24,13 @@ export declare function setTaskToolHooks(hooks: TaskToolHooks | undefined): void
  * If null, ask_user returns "user declined" to the LLM.
  */
 export declare function setAskUserCallback(callback: ((questions: AskUserQuestion[]) => Promise<Record<string, string> | null>) | null): void;
-/**
- * Set the media client + API keys for generation tools.
- * Tools will call vendor APIs directly through MediaTransport.
- * Keys map: { providerId: apiKey, ... }
- * Providers map: { "image": { provider: "volcengine", model: "doubao-seedream-5-0-260128" }, ... }
- */
-export declare function setMediaClientConfig(client: MediaClient | undefined, apiKeys?: Record<string, string>, onMediaUsage?: (model: string, billingUnit: string, quantity: number) => void, providers?: Partial<Record<MediaCapability, {
-    provider: string;
-    model: string;
-}>>, onMediaProgress?: (taskId: string, mediaType: string, percent: number, status: string, provider?: string) => void): void;
-/** Legacy no-op — workspace boundary is now always enforced for writes. */
-export declare function setBypassWorkspaceBoundary(_bypass: boolean): void;
+/** Enable full-access mode for trusted sessions that may operate outside the workspace. */
+export declare function setBypassWorkspaceBoundary(bypass: boolean): void;
 export declare function setBootstrapWorkdir(newWorkdir: string): void;
 export interface BootstrapConfig {
     workdir?: string;
+    toolCatalog?: ToolCatalog;
+    pathService?: PathService;
     log?: AgentLogger;
     /** Called during foreground shell execution with incremental progress. */
     onExecProgress?(progress: ExecProgress): void;
@@ -54,6 +41,6 @@ export interface BootstrapConfig {
  * CC parity: getAllBaseTools() returns flat array, installed via setToolPool().
  * Tools execute IN-PROCESS (zero IPC).
  *
- * @alias initToolDeps — kept for backward compat with existing call sites.
+ * @alias initToolDeps -kept for backward compat with existing call sites.
  */
 export declare function getAllBaseTools(config?: BootstrapConfig): PortableTool[];

package/dist/types/cli/tool-catalog.d.ts

@@ -1,2 +1,4 @@
-import type { ToolCatalog } from "../runtime/ports/index.js";
-export declare function createCliToolCatalog(): ToolCatalog;
+import type { ToolBootstrap, ToolCatalog } from "../runtime/ports/index.js";
+import { type ToolRegistry } from "./tool-registry-adapter.js";
+export declare function createCliToolCatalog(registry?: ToolRegistry): ToolCatalog;
+export declare function createCliToolBootstrap(toolCatalog?: ToolCatalog): ToolBootstrap;

package/dist/types/cli/tool-invoker-factory.d.ts

@@ -1,8 +1,10 @@
 import type { ToolInvoker } from "../agent/types.js";
 import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
 import type { MediaPersistence } from "../runtime/infra/media-persistence.js";
+import type { ToolCatalog } from "../runtime/ports/index.js";
 export interface LocalToolInvokerDeps {
     mediaPersistence: MediaPersistence;
+    toolCatalog: ToolCatalog;
     getSessionId(): string;
     log(message: string): void;
     sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;

package/dist/types/cli/tool-registry-adapter.d.ts

@@ -0,0 +1,5 @@
+import { type ToolRegistry } from "../skills/tools.js";
+import type { ToolCatalog } from "../runtime/ports/index.js";
+export type { ToolRegistry };
+export declare function createToolCatalogFromRegistry(registry?: ToolRegistry): ToolCatalog;
+export declare function createLegacyToolCatalog(): ToolCatalog;

package/dist/types/contracts/hooks.d.ts

@@ -28,7 +28,7 @@ export interface HookApprovalContext extends HookTurnContext {
     approvalId: string;
     callId?: string;
     toolName?: string;
-    decision?: "approved" | "denied" | "expired" | "cancelled";
+    decision?: "allow" | "deny" | "expired" | "cancelled";
 }
 export interface HookSubagentContext extends HookTurnContext {
     subagentId: string;

package/dist/types/index.d.ts

@@ -10,7 +10,6 @@ export type { AgentConfig } from "./config/config.js";
 export type { Transport } from "./cli/transport.js";
 export { StdioTransport } from "./cli/transport.js";
 export { StdioServer, type StdioServerConfig } from "./cli/stdio-server.js";
-export { ProviderRegistry, createLLMClient, } from "@xiaozhiclaw/provider-core";
-export type { LLMTransport, LLMRequest, LLMChunk } from "@xiaozhiclaw/provider-core";
+export type { LLMTransport, LLMRequest, LLMChunk } from "./runtime/ports/index.js";
 export { createHookRegistry } from "./runtime/hooks/hook-registry.js";
 export { buildSkillInstruction, } from "./orchestration/index.js";

package/dist/types/orchestration/product-persistence.d.ts

@@ -4,6 +4,7 @@
  * State is stored at `<project>/.qlogicagent/products/<productId>/product-state.json`.
  * Product listing is done by enumerating subdirectories.
  */
+import type { PathService } from "../runtime/ports/index.js";
 import type { ProductPhase, ProductInstanceDef } from "../protocol/wire/acp-agent-management.js";
 import type { SerializedNode } from "./dag-scheduler.js";
 export interface PersistedProductState {
@@ -23,9 +24,12 @@ export interface PersistedProductState {
     createdAt: string;
     lastCheckpointAt: string;
 }
+export interface ProductPersistenceOptions {
+    pathService?: PathService;
+}
 /** Save product state to disk. */
-export declare function saveProductState(state: PersistedProductState, cwd?: string): Promise<void>;
+export declare function saveProductState(state: PersistedProductState, cwd?: string, options?: ProductPersistenceOptions): Promise<void>;
 /** Load product state from disk. Returns undefined if not found. */
-export declare function loadProductState(productId: string, cwd?: string): Promise<PersistedProductState | undefined>;
+export declare function loadProductState(productId: string, cwd?: string, options?: ProductPersistenceOptions): Promise<PersistedProductState | undefined>;
 /** List all product IDs with their persisted state. */
-export declare function listProducts(cwd?: string): Promise<PersistedProductState[]>;
+export declare function listProducts(cwd?: string, options?: ProductPersistenceOptions): Promise<PersistedProductState[]>;

package/dist/types/orchestration/solo-persistence.d.ts

@@ -4,6 +4,7 @@
  * State is stored at `<project>/.qlogicagent/solos/<soloId>/solo-state.json`.
  * Mirrors the product-persistence.ts pattern.
  */
+import type { PathService } from "../runtime/ports/index.js";
 import type { SoloState, SoloAgentState, SoloEvaluation } from "../protocol/wire/acp-agent-management.js";
 export interface PersistedSoloState {
     soloId: string;
@@ -33,11 +34,14 @@ export interface PersistedSoloState {
     evaluation?: SoloEvaluation;
     createdAt: number;
 }
+export interface SoloPersistenceOptions {
+    pathService?: PathService;
+}
 /** Save solo state to disk. */
-export declare function saveSoloState(state: PersistedSoloState, cwd?: string): Promise<void>;
+export declare function saveSoloState(state: PersistedSoloState, cwd?: string, options?: SoloPersistenceOptions): Promise<void>;
 /** Load solo state from disk. Returns undefined if not found. */
-export declare function loadSoloState(soloId: string, cwd?: string): Promise<PersistedSoloState | undefined>;
+export declare function loadSoloState(soloId: string, cwd?: string, options?: SoloPersistenceOptions): Promise<PersistedSoloState | undefined>;
 /** List all solo session IDs with their persisted state. */
-export declare function listSoloSessions(cwd?: string): Promise<PersistedSoloState[]>;
+export declare function listSoloSessions(cwd?: string, options?: SoloPersistenceOptions): Promise<PersistedSoloState[]>;
 /** Delete solo state from disk. */
-export declare function deleteSoloState(soloId: string, cwd?: string): Promise<boolean>;
+export declare function deleteSoloState(soloId: string, cwd?: string, options?: SoloPersistenceOptions): Promise<boolean>;

package/dist/types/orchestration/subagent/agent-registry.d.ts

@@ -14,9 +14,9 @@ export interface AgentDefinition {
     description: string;
     /** Maximum turns this agent can execute before forced stop. */
     maxTurns: number;
-    /** Tool access mode. */
-    toolAccessMode: "full" | "read-only" | "none";
-    /** Explicit allowed tool names (if empty, uses toolAccessMode filter). */
+    /** Tool capability profile. This is not a user permission mode. */
+    toolCapabilityProfile: "all_tools" | "read_tools" | "no_tools";
+    /** Explicit allowed tool names (if empty, uses toolCapabilityProfile filter). */
     allowedTools?: string[];
     /** Whether this agent can fork sub-agents itself. */
     canFork: boolean;