qlogicagent 2.18.5 → 2.18.7

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

@@ -1,13 +1,8 @@
 /**
- * Config + tunables handlers — extracted from StdioServer.
- * Handles: config.get, config.update, config.tunables, config.updateTunable,
- *          provider.list, tools.list, todos.list, tasks.list, tasks.cancel
- *
- * NOTE: Provider/model/key management is handled by settings-handler.ts (settings.* RPC).
- * config.get/config.update only operate on tunables and non-model settings.
+ * Provider/catalog and task-list handlers retained after the public config.* RPC teardown.
+ * Profile/tunable state is gateway-owned and is available to agent tools only through private X7.
  */
 import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
-import type { PermissionMode } from "../../runtime/ports/index.js";
 import type { BackgroundTaskManager } from "../../runtime/infra/background-tasks.js";
 import type { TaskStore } from "../../runtime/infra/task-runtime.js";
 import type { ToolCatalog } from "../../runtime/ports/index.js";
@@ -16,18 +11,10 @@ export interface ConfigHandlerHost {
     backgroundTasks: BackgroundTaskManager;
     toolCatalog?: ToolCatalog;
     syncToolListMediaConfig?(): void;
-    /** 权限热应用:config.update 写盘后立即同步活的 rule engine(否则要等下一轮 _meta/重启)。 */
-    applyPermissionConfig?(perm: {
-        mode: PermissionMode;
-    }): void;
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
 }
 export declare function handleToolsList(this: ConfigHandlerHost, msg: AgentRpcRequest): void;
 export declare function handleProviderList(this: ConfigHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleConfigGet(this: ConfigHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleConfigUpdate(this: ConfigHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleConfigTunables(this: ConfigHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleConfigUpdateTunable(this: ConfigHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleTodosList(this: ConfigHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleTasksList(this: ConfigHandlerHost, msg: AgentRpcRequest): void;
 export declare function handleTasksCancel(this: ConfigHandlerHost, msg: AgentRpcRequest): void;

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

@@ -17,6 +17,10 @@ export interface DreamHandlerHost {
     currentHooks?: DreamRunDeps["hooks"] | null;
     memoryProvider?: DreamMemoryProvider | null;
     memoryUserId?: string;
+    /** Lazy read-path init for the L2 memory provider (cheap, side-effect-free DB open). Consumers
+     *  that can run before any turn (goal planning's orchestration memory context, memory.atlas)
+     *  must call this before reading memoryProvider — on a cold process nothing else has built it. */
+    ensureMemoryProvider?(): void;
     toolCatalog: ToolCatalog;
     taskStore: TaskStore;
     verbose?: boolean;

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

@@ -14,7 +14,8 @@ interface PetMemoryActivitySummary {
     }>;
 }
 interface PetMemoryProviderLike {
-    getActivitySummary(userId: string, days: number): PetMemoryActivitySummary | undefined;
+    /** B3(X7)异步化:16 面 host-state proxy 方法(host 模式经 x/host.request 跨进程)。 */
+    getActivitySummary(userId: string, days: number): Promise<PetMemoryActivitySummary | undefined> | undefined;
 }
 interface PetSessionStateLike {
     turnCount?: number;
@@ -25,7 +26,7 @@ export interface PetHandlerHost {
     memoryProvider?: PetMemoryProviderLike | null;
     memoryUserId?: string;
     ownerUserId?: string;
-    petRuntime: Pick<PetRuntime, "createPetSoulGenerator" | "createSmallLLMCall" | "forgeAnalyzeImage"> & Partial<Pick<PetRuntime, "forgeGeneratePetdexAtlas" | "isImageGenerationAvailable" | "isPetdexForgeAvailable">>;
+    petRuntime: Pick<PetRuntime, "createPetSoulGenerator" | "createSmallLLMCall"> & Partial<Pick<PetRuntime, "forgeGeneratePetdexAtlas" | "isImageGenerationAvailable" | "isPetdexForgeAvailable">>;
     getActiveProjectRoot(): string;
     sendNotification(method: string, params: Record<string, unknown>): void;
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;

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

@@ -90,7 +90,7 @@ export declare function handleSessionArchive(this: SessionHandlerHost, msg: Agen
 export declare function handleSessionMarkCleanShutdown(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleSessionResume(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleSessionGetInfo(this: SessionHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleSessionSwitchProject(this: SessionHandlerHost, msg: AgentRpcRequest): void;
+export declare function handleSessionSwitchProject(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleSessionGetState(this: SessionHandlerHost, msg: AgentRpcRequest): void;
 /**
  * `session.focus` - Desktop UI reports which session is currently focused.

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

@@ -5,11 +5,13 @@
  *          skills.curator, skills.lifecycle
  */
 import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
+import type { HostCapabilityClient } from "../../transport/host-capability-client.js";
 export interface SkillsHandlerHost {
     projectLocator?: {
         resolveProjectRoot(projectId: string): string | undefined;
     };
     getActiveProjectRoot(): string;
+    getHostCapabilityClient(): HostCapabilityClient | undefined;
     sendNotification(method: string, params: Record<string, unknown>): void;
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
 }
@@ -17,19 +19,19 @@ export declare function extractSkillMeta(skillMdPath: string): {
     version?: string;
     description?: string;
 };
-export declare function handleSkillsList(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleSkillsActivate(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleSkillsDeactivate(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
+export declare function handleSkillsList(this: SkillsHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSkillsActivate(this: SkillsHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSkillsDeactivate(this: SkillsHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleSkillsDelete(this: SkillsHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleSkillsPromote(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
+export declare function handleSkillsPromote(this: SkillsHandlerHost, msg: AgentRpcRequest): Promise<void>;
 /**
  * Per-project opt-out: mute (or un-mute) a globally-installed skill in ONE project so the agent
  * doesn't see it there — cuts context and mis-triggering without uninstalling the skill. The file
  * stays in the global store and stays active in every other project. This is the "本项目技能" toggle.
  */
-export declare function handleSkillsSetProjectDisabled(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleSkillsStats(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleSkillsPin(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleSkillsUnpin(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleSkillsCurator(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleSkillsLifecycle(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
+export declare function handleSkillsSetProjectDisabled(this: SkillsHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSkillsStats(this: SkillsHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSkillsPin(this: SkillsHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSkillsUnpin(this: SkillsHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSkillsCurator(this: SkillsHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleSkillsLifecycle(this: SkillsHandlerHost, msg: AgentRpcRequest): Promise<void>;

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

@@ -7,6 +7,7 @@ import { AgentProcessManager } from "../../runtime/infra/agent-process.js";
 import type { AcpDetector } from "../../runtime/infra/acp-detector.js";
 import type { AgentConfigStore } from "../../runtime/infra/agent-config-store.js";
 import { SoloEvaluator } from "../../orchestration/solo-evaluator.js";
+import type { DelegateBridge } from "../../orchestration/delegation-coordinator.js";
 import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
 export declare const soloProjectMap: Map<string, string>;
 export interface SoloHandlerHost {
@@ -26,6 +27,8 @@ export interface SoloHandlerHost {
         };
     }): void;
     handleMcpToolCall(memberId: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    /** 激活层(S3c §1.5):gateway-routed delegate 桥(懒读;未挂/gate 关 = undefined → 旧本地 spawn 路径)。 */
+    getDelegateBridge?(): DelegateBridge | undefined;
 }
 export declare function ensureSoloEvaluator(this: SoloHandlerHost): SoloEvaluator;
 export declare function handleSoloStart(this: SoloHandlerHost, msg: AgentRpcRequest): Promise<void>;

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

@@ -3,7 +3,7 @@
  * Handles: the shared turn pipeline (runTurnPipeline) + thread.user_response (ask-user answers).
  */
 import { type ModelPurpose } from "../../runtime/infra/model-registry.js";
-import { type UnderstandMediaClient, type UnderstandMediaKind } from "../media-understanding.js";
+import { type UnderstandMediaKind } from "../media-understanding.js";
 import { type InstructionFileInfo } from "../../runtime/prompt/instruction-loader.js";
 import type { HookRegistry } from "../../contracts/hooks.js";
 import type { AppendMessageOutcome } from "../../runtime/session/session-transcript-store.js";
@@ -98,9 +98,6 @@ export declare function loadInstructionBlockForTurn(deps: {
 }): Promise<string | undefined>;
 export declare function hydrateTurnConfigFromModelMetadata(config: TurnConfig): TurnConfig;
 export declare function hydrateAttachmentReferenceUrlsForTurn(messages: ChatMessage[]): ChatMessage[];
-export declare function getFocusedAttachmentToolNamesForTurn(messages: ChatMessage[]): Set<string> | null;
-type FocusedAttachmentModelPurpose = "imageUnderstanding" | "videoUnderstanding";
-export declare function getFocusedAttachmentUnsupportedContentForTurn(messages: ChatMessage[], purpose: FocusedAttachmentModelPurpose): string | null;
 /**
  * Return a shallow-cloned message array whose LAST user message has the model-facing attachment
  * context (numbered manifest / reference URLs / picked-element selector+styles) appended to its
@@ -145,44 +142,61 @@ export declare function injectSkillContextBeforeLastUser(messages: ChatMessage[]
  */
 export declare function buildMemoryIndexBlock(globalBlock: string | null, projectBlock: string | null): string | null;
 export declare function injectDomainGuidanceBeforeLastUser(messages: ChatMessage[], domainGuidance: string): ChatMessage[];
-export declare function getFocusedAttachmentModelPurposeForTurn(messages: ChatMessage[]): FocusedAttachmentModelPurpose | null;
 export declare function refreshPermissionCheckerToolMeta(permissionChecker: PermissionMetadataResolver | null | undefined, tools: ToolDefinition[]): void;
 export declare function handleUserResponse(this: TurnControlHandlerHost, msg: AgentRpcRequest): void;
-/**
- * Pure: assemble the text appended to the user message after modality routing.
- * `descriptorsByKind` are the successfully understood texts (in order per modality);
- * `fallbackStripped` are the "X 张图片"-style labels for media that was dropped without
- * understanding. Returns "" when there is nothing to inject.
- *
- * The understood blocks lead with a note stating they are model transcriptions; the
- * "media omitted" note is appended ONLY for the fallback set, so a successful transcription
- * is never contradicted by a blanket "media omitted" line.
- */
-export declare function buildUnderstoodInjection(descriptorsByKind: Record<UnderstandMediaKind, string[]>, fallbackStripped: string[]): string;
 interface ModalityRegistryView {
     acceptsInputModality(modality: string, purpose: ModelPurpose): boolean;
     isAvailable(purpose: ModelPurpose): boolean;
 }
-interface RouteUnsupportedModalitiesDeps {
-    lastUserMsg: ChatMessage;
-    purpose: ModelPurpose;
-    registry: ModalityRegistryView;
-    resolveClient(purpose: ModelPurpose): UnderstandMediaClient | null;
-    signal?: AbortSignal;
-    log(message: string): void;
+export interface UnsupportedMediaRefs {
+    image: string[];
+    video: string[];
+    audio: string[];
+}
+/** Plan for the media a text-only main model can't consume, produced by detectUnsupportedMediaForTools. */
+export interface MediaUnderstandingPlan {
+    /** Refs the model should call the understanding tool on — understanding model bound AND the ref is
+     *  tool-addressable (a short URL/path it can echo). Capped when surfaced (see the notice builder). */
+    toolRefs: UnsupportedMediaRefs;
+    /** Kinds present but NOT understandable this turn: no understanding model is bound for them, or every
+     *  ref is a non-addressable (data:/oversized) URL. Surfaced as an HONEST "cannot read this" note so
+     *  the model never points at an absent tool while being forbidden to admit blindness. */
+    blockedKinds: UnderstandMediaKind[];
 }
 /**
- * For each modality the resolved main model can't consume, route the media to its
- * understanding model (image→imageUnderstanding, audio→stt, video→videoUnderstanding)
- * and fold the returned text into the user message; media that can't be understood
- * (model unavailable / call failed / empty / over the cap) degrades to the previous
- * behavior (field dropped + omission note). The media field is ALWAYS deleted afterward
- * — the main model still can't consume it, so leaving it would 400 the turn.
+ * Detect the media modalities the resolved main model can't consume, STRIP the media fields (a text-only
+ * model 400s on multimodal content), and PLAN what to tell the model: which refs to call the understanding
+ * tool on, and which kinds it must honestly report as unreadable (no understanding model bound, or every
+ * ref is a non-addressable data:/oversized URL). It does NOT transcribe and does NOT touch the message
+ * text — the plan is surfaced via a model-only notice so the model calls image_understand /
+ * video_understand / stt itself, exactly as it would for an in-message media path; the user's bubble
+ * stays clean. This is the ONLY media-understanding path (the legacy eager pre-inject was fully retired).
+ *
+ * Reliability note: unlike the eager path, this DEPENDS on the model calling the tool — the medium is not
+ * transcribed anywhere, so if the model ignores the notice the understanding does not happen this turn
+ * (mitigated by the strong notice). Cross-turn is fine WITHIN a live session: the model's prior
+ * image_understand call (carrying the image_url ref) stays in the running conversation, so a later turn
+ * can re-read the same image — verified by a 2-turn test. The only gap is a COLD resume: the on-disk
+ * transcript stores just the user text (media stripped) + the assistant's text, not the tool calls/results
+ * (see appendMessage), so re-opening the session in a fresh process rebuilds history without the ref —
+ * the model then has only its earlier answer text, not a way to look again.
  *
- * Mutates `lastUserMsg` in place. Injection only touches string content (array content is
- * left as-is, matching the prior behavior). Best-effort: never throws for a per-item failure.
+ * Attachments were saved to disk + rewritten to short gateway local-media URLs by persistInboundUploadsForTurn
+ * upstream, so a proxy ref is compact; isToolAddressableRef guards the residual raw-data: case. Mutates
+ * `lastUserMsg` (deletes the consumed media fields).
+ */
+export declare function detectUnsupportedMediaForTools(lastUserMsg: ChatMessage, purpose: ModelPurpose, registry: ModalityRegistryView): MediaUnderstandingPlan;
+/**
+ * Build the MODEL-ONLY notice for a MediaUnderstandingPlan. Understandable media → a directive to call the
+ * matching tool on each listed ref (capped at MAX_MEDIA_UNDERSTAND_REFS). Blocked media → an HONEST
+ * "cannot read this, do not guess" note (no understanding model / unaddressable ref) — never a directive to
+ * call an absent tool. For a user ATTACHMENT the notice rides the LLM copy of the user message
+ * (effectiveMessages), NEVER the persisted/displayed message, so the bubble stays clean; for a TOOL RESULT
+ * it is appended to the tool-result content. Returns "" when there is no unconsumable media.
  */
-export declare function routeUnsupportedModalitiesToUnderstanding(deps: RouteUnsupportedModalitiesDeps): Promise<void>;
+export declare function buildMediaUnderstandingToolNotice(plan: MediaUnderstandingPlan, opts?: {
+    source?: "attachment" | "tool_result";
+}): string;
 export interface TurnPipelineInput {
     turnId: string;
     sessionId: string;

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

@@ -8,6 +8,7 @@
  */
 import { AgentProcessManager } from "../../runtime/infra/agent-process.js";
 import type { AcpDetector } from "../../runtime/infra/acp-detector.js";
+import type { DelegateBridge } from "../../orchestration/delegation-coordinator.js";
 import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
 import { WorkflowController } from "../../orchestration/workflow/workflow-controller.js";
 import { WorkflowStore, type WorkflowRecord } from "../../orchestration/workflow/workflow-store.js";
@@ -46,6 +47,11 @@ export interface WorkflowCoordinatorHost {
     } | null;
     /** Per-root engine bundles keyed by resolved cwd; built lazily by ensureWorkflowRoot. */
     workflowRoots: Map<string, WorkflowRootBundle> | null;
+    /**
+     * 激活层(S3c §1.6):gateway-routed delegate 桥(gateway 在 initialize 声明 delegate 能力位时
+     * 才 isSupported;缺省/gate 关 = 旧 AgentProcessManager 本地 spawn 路径,单轨保留零回归)。
+     */
+    getDelegateBridge?(): DelegateBridge | undefined;
 }
 export interface WorkflowHandlerHost extends WorkflowCoordinatorHost {
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;

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

@@ -13,9 +13,7 @@ export interface McpBootstrapDeps {
 }
 export declare const mcpToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<McpBootstrapDeps>;
 export declare function configureMcpBootstrap(deps: McpBootstrapDeps): void;
-export declare function readUserMcpConfig(pathService: PathService, log?: RuntimeLogger): unknown;
 export declare function buildMcpBootstrapEntries(params: {
     turnMcpConfig?: unknown;
-    userMcpConfig?: unknown;
     projectRoot: string;
 }): import("../skills/mcp/mcp-manager.js").McpServerEntry[];

package/dist/types/cli/media-inline.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Resolve a media reference into a form a REMOTE model can consume, by rewriting a LOCAL file path to
+ * the gateway's `/api/media/local?src=file://…` proxy URL.
+ *
+ * Why the proxy URL (not a raw path, not base64, not the provider file-API upload):
+ *  - A tool result (e.g. the `read` tool reading a workspace image) carries a RAW local path
+ *    (`C:\…\assets\images\x.jpg`) a remote model cannot fetch → the understanding model returns empty.
+ *  - A base64 `data:` URL blows past the LLM gateway's request-size limit → HTTP 413.
+ *  - The provider file-API upload (media-file-api-service) needs a Files-API provider that isn't always
+ *    configured → "no provider".
+ *  - The `127.0.0.1/api/media/local` proxy URL is exactly what user-attachments use: provider-core's
+ *    FileUploadAdapter (given QLOGICAGENT_HUB_URL) relays it to hub OSS → a small public URL. Proven path.
+ *
+ * Remote (`http`/`https`/`data`/`blob`) URLs, non-media extensions, and missing files pass through
+ * unchanged. Never throws.
+ */
+export declare function resolveLocalMediaForModel(url: string): string;
+/**
+ * Resolve an IMAGE reference for an understanding call, preferring a self-contained base64 `data:` URL
+ * for a small LOCAL image over the upload path. A local image inlined as base64 is delivered inside the
+ * request (the model provider fetches nothing), so it sidesteps the whole local→upload→OSS→signed-URL
+ * chain that a text main model's image understanding otherwise depends on (an unsigned private-OSS URL
+ * the provider 403s on is the classic silent-empty fault). Behavior:
+ *  - `data:` URL → returned as-is (already inline).
+ *  - public `http(s)`/`blob:` URL → returned as-is (the provider fetches it server-side).
+ *  - LOCAL image (raw path / `file://` / the 127.0.0.1 media-proxy URL) within the inline ceiling →
+ *    read + base64 `data:` URL.
+ *  - LOCAL image over the ceiling (or unreadable) → fall back to resolveLocalMediaForModel (proxy/upload).
+ * Only images inline as base64 — video is far too large, so it always takes the URL path. Never throws.
+ */
+export declare function resolveImageForUnderstanding(url: string): string;

package/dist/types/cli/media-understanding.d.ts

@@ -20,6 +20,22 @@ export declare const PURPOSE_BY_KIND: Record<UnderstandMediaKind, "imageUndersta
 export declare const URL_FIELD_BY_KIND: Record<UnderstandMediaKind, "imageUrls" | "audioUrls" | "videoUrls">;
 /** Per-medium instruction. Every kind is normalized to plain text so callers only swap a label. */
 export declare const PROMPT_BY_KIND: Record<UnderstandMediaKind, string>;
+/**
+ * The subset of stream-chunk fields understandMediaUrl inspects. Deliberately loose and
+ * all-optional beyond `type` so it stays structurally compatible with the real LLMTransport's
+ * discriminated LLMChunk union (delta / usage / error / done all satisfy it) and the memory
+ * client. Beyond the `delta` text we read the `usage` tokens and the terminal `error` / `done`
+ * so an empty reply can be diagnosed (medium never reached the model) rather than silently
+ * reported as a blank description.
+ */
+export interface UnderstandMediaChunk {
+    type: string;
+    text?: string;
+    promptTokens?: number;
+    completionTokens?: number;
+    finishReason?: string;
+    message?: string;
+}
 /**
  * A resolved understanding client. Structurally compatible with both the real LLMTransport
  * (whose `stream` takes an optional third `signal` arg) and the memory client. Deliberately
@@ -29,17 +45,58 @@ export interface UnderstandMediaClient {
     model: string;
     apiKey: string;
     transport: {
-        stream(request: Record<string, unknown>, apiKey: string, signal?: AbortSignal): AsyncIterable<{
-            type: string;
-            text?: string;
-        }>;
+        stream(request: object, apiKey: string, signal?: AbortSignal): AsyncIterable<UnderstandMediaChunk>;
     };
 }
 /**
- * Understand a single medium at `url` and return the model's trimmed text (may be empty
- * if the model produced nothing). Never throws for an empty reply — an empty string is a
- * valid "no text" result the caller degrades on.
+ * Why an understanding call yielded no usable text. Lets callers separate a genuine "the model
+ * looked and had nothing to say" (`empty_output`) from "the medium never reached the model"
+ * (`fetch_failed`) — the silent-empty failure mode where an unfetchable image (e.g. a private-OSS
+ * URL the provider 403s on) bills zero input tokens, so an empty reply is a delivery failure, not
+ * a blank description. `stream_error` is an explicit upstream error surfaced mid-stream.
+ */
+export type MediaUnderstandFailure = "fetch_failed" | "stream_error" | "empty_output";
+/**
+ * Structured outcome of understandMediaUrl. `text` is the transcript (empty ⇔ the model produced
+ * no text); when `text` is empty, `failure` classifies WHY so callers can surface a delivery
+ * failure distinctly instead of treating every empty reply as "nothing to describe". The token /
+ * finishReason fields carry the diagnostic evidence for logs.
+ */
+export interface UnderstandMediaResult {
+    /** The model's trimmed text. Empty string ⇔ no text was produced (see `failure`). */
+    text: string;
+    /** Input tokens the provider billed, if a usage chunk arrived. undefined ⇔ no usage chunk was
+     * seen at all — itself a strong "nothing reached, or came back from, the model" signal. */
+    promptTokens?: number;
+    /** Output tokens, if a usage chunk arrived. */
+    completionTokens?: number;
+    /** finishReason from the terminal chunk ("" / undefined ⇔ truncated or none). */
+    finishReason?: string;
+    /** Message from an explicit `error` chunk, if the stream surfaced one. */
+    errorText?: string;
+    /** Set when the reply is not a trustworthy result. Usually `text` is empty, but `fetch_failed` can
+     * accompany NON-empty `text` — an image billed at text-only tokens was never seen, so its "description"
+     * is confabulated. undefined ⇔ a real success; when set, callers must NOT treat `text` as valid. */
+    failure?: MediaUnderstandFailure;
+}
+/**
+ * Stream an already-built understanding request and classify an empty reply. Placement of the
+ * prompt and media URL(s) onto the request is the CALLER's job — this owns only the streaming +
+ * diagnosis, so every vision caller (the turn gate's understandMediaUrl AND the pet forge's image
+ * analysis / vision-QA) shares ONE definition of "fetch_failed vs empty_output vs stream_error"
+ * instead of each re-deriving it from a thin delta-only loop. `kind` drives only the image
+ * token-floor heuristic — pass the kind of the primary medium carried on the request.
+ */
+export declare function streamUnderstanding(client: UnderstandMediaClient, request: Record<string, unknown>, kind: UnderstandMediaKind, opts?: {
+    signal?: AbortSignal;
+}): Promise<UnderstandMediaResult>;
+/**
+ * Understand a single medium at `url`. Returns a structured result: the trimmed text (may be
+ * empty) plus, when empty, a `failure` classifying WHY. Never throws for an empty reply — the
+ * caller decides how to degrade, but can now tell a delivery failure (`fetch_failed`) apart from a
+ * blank description (`empty_output`) instead of treating every empty reply the same. Thin wrapper
+ * over streamUnderstanding that builds the single-URL, modality-correct request.
  */
 export declare function understandMediaUrl(client: UnderstandMediaClient, kind: UnderstandMediaKind, url: string, opts?: {
     signal?: AbortSignal;
-}): Promise<string>;
+}): Promise<UnderstandMediaResult>;

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

@@ -1,3 +1,4 @@
+import { type HostRequestRequester } from "../skills/memory/host-memory-provider.js";
 import { type MemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
 import type { HookRegistry } from "../contracts/hooks.js";
 import type { RuntimeLogger } from "../runtime/hooks/hook-registry.js";
@@ -12,6 +13,13 @@ export interface MemoryProviderState {
     dreamProvider: MemoryDreamRuntimeProvider | null;
     userId: string;
 }
+/** Host-request access exposed by the ACP protocol coordinator. */
+export interface MemoryHostRequestAccess {
+    supportsHostRequestService(service: "memory"): boolean;
+    readonly hostRequest: HostRequestRequester;
+}
+/** 装配期绑定(stdio-runtime-services 注入;lazy resolver——gate 在创建时刻现读)。重绑重置选型护栏。 */
+export declare function bindMemoryHostRequestAccess(resolve: () => MemoryHostRequestAccess | null): void;
 export declare function ensureLocalMemoryProvider(currentUserId: string): MemoryProviderState;
 export interface RegisterMemoryRuntimeHooksDeps {
     hooks: HookRegistry;

package/dist/types/cli/multi-agent-handler-host.d.ts

@@ -22,6 +22,8 @@ export interface MultiAgentHandlerHostDeps {
     log(message: string): void;
     sendNotification(method: string, params: Record<string, unknown>): void;
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
+    /** 激活层(S3c):gateway-routed delegate 桥(懒读;未挂/gate 关 = undefined → 各旧本地 spawn 路径)。 */
+    getDelegateBridge?: ProductHandlerHost["getDelegateBridge"];
 }
 export declare function createMultiAgentHandlerHost(deps: MultiAgentHandlerHostDeps): MultiAgentHandlerHost;
 export {};

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

@@ -2,6 +2,7 @@ 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 { ToolCatalog } from "../runtime/ports/index.js";
+import type { HostProfileClient } from "../transport/host-profile-client.js";
 import { type RuntimePermissionChecker, type RuntimePermissionRuleEngine } from "./permission-runtime-service.js";
 export { createApprovalResponseFromAcpOption } from "./permission-approval-bridge.js";
 export interface PermissionBootstrapDeps {
@@ -30,6 +31,7 @@ export interface PermissionBootstrapDeps {
     } | undefined;
     sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
     isPetActive(): boolean;
+    resolveHostProfileClient?: () => HostProfileClient | undefined;
     currentUnregister?: (() => void) | null;
 }
 export interface PermissionBootstrapResult {

package/dist/types/cli/pet-runtime.d.ts

@@ -40,7 +40,6 @@ export interface PetLlmClient {
 export interface PetRuntime {
     createPetSoulGenerator(): PetSoulGenerator | undefined;
     createSmallLLMCall(): SmallLlmCall | undefined;
-    forgeAnalyzeImage(imageBase64: string, hint?: string): Promise<string>;
     isImageGenerationAvailable(): boolean;
     isPetdexForgeAvailable(): boolean;
     forgeGeneratePetdexAtlas(input: PetdexForgeInput): Promise<PetdexForgeOutput>;

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

@@ -2,6 +2,7 @@ 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 declare const HOST_PLUGIN_REFS_FILE_ENV = "QLOGICAGENT_HOST_PLUGIN_REFS_FILE";
 export interface PluginBootstrapDeps {
     config: Record<string, unknown>;
     hooks: HookRegistry;
@@ -12,4 +13,4 @@ export interface PluginBootstrapDeps {
 }
 export declare const pluginToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<PluginBootstrapDeps>;
 export declare function configurePluginBootstrap(deps: PluginBootstrapDeps): void;
-export declare function resolvePluginDirsFromConfig(config: Record<string, unknown>, pathService: PathService): string[];
+export declare function resolvePluginDirsFromConfig(config: Record<string, unknown>, _pathService: PathService, hostRefs?: readonly string[]): string[];

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

@@ -1,5 +1,6 @@
 import { ProductOrchestrator } from "../orchestration/agent-instance.js";
 import { ProductPlanner } from "../orchestration/product-planner.js";
+import type { DelegateBridge } from "../orchestration/delegation-coordinator.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";
@@ -20,6 +21,8 @@ export interface ProductCoordinatorHost {
     }): void;
     handleMcpToolCall(memberId: string, tool: string, args: Record<string, unknown>): Promise<unknown>;
     sendNotification(method: string, params: Record<string, unknown>): void;
+    /** 激活层(S3c):gateway-routed delegate 桥(gate 关/未挂 = undefined → 旧本地 spawn 路径)。 */
+    getDelegateBridge?(): DelegateBridge | undefined;
 }
 /** productId → 容器项目 id(R2 容器优先,与 solo-handler.soloProjectMap 对称)。终态回写用。
  *  定义在此(callbacks 所在文件)与 solo 对称;product-handler 再导出供 ACP 入口/测试引用。 */
@@ -29,6 +32,6 @@ export declare const productProjectMap: Map<string, string>;
  * 刷新后留存。**仅当项目仍 "running" 时迁移**——避免"完成晚到覆盖取消"或反向覆盖(R1 cancel-clobber
  * 教训)。成功 → "completed";失败 → "failed";取消 → "cancelled"。
  */
-export declare function writeProductTerminalPlanStatus(host: ProductCoordinatorHost, productId: string, status: "completed" | "failed" | "cancelled"): void;
+export declare function writeProductTerminalPlanStatus(host: ProductCoordinatorHost, productId: string, status: "completed" | "failed" | "cancelled"): Promise<void>;
 export declare function ensureProductOrchestrator(host: ProductCoordinatorHost): ProductOrchestrator;
 export declare function ensureProductPlanner(host: ProductCoordinatorHost): ProductPlanner;

package/dist/types/cli/rpc-registry.d.ts

@@ -10,7 +10,6 @@ import { type PetHandlerHost } from "./handlers/pet-handler.js";
 import { type WorkflowHandlerHost } from "./handlers/workflow-handler.js";
 import { type ProjectHandlerHost } from "./handlers/project-handler.js";
 import { type SessionHandlerHost } from "./handlers/session-handler.js";
-import { type SettingsHandlerHost } from "./handlers/settings-handler.js";
 import { type SkillsHandlerHost } from "./handlers/skills-handler.js";
 import { type TurnBaselineHandlerHost } from "./handlers/turn-baseline-handler.js";
 import { type MessageFeedbackHandlerHost } from "./handlers/message-feedback-handler.js";
@@ -18,7 +17,7 @@ import { type TurnControlHandlerHost } from "./handlers/turn-handler.js";
 import { type WorkingMaterialsHandlerHost } from "./handlers/working-materials-handler.js";
 import { type DreamHandlerHost } from "./handlers/dream-handler.js";
 import type { MultiAgentHandlerHost } from "./multi-agent-handler-host.js";
-export type RpcMethodHandler = (msg: AgentRpcRequest) => void;
+export type RpcMethodHandler = (msg: AgentRpcRequest) => void | Promise<void>;
 /**
  * Per-domain host adapters the RPC registry binds handlers to. Each field is
  * typed to exactly ONE handler's narrow contract, so the host (StdioServer)
@@ -59,7 +58,6 @@ export interface RpcHandlerHosts {
     petConfirm: PetConfirmHandlerHost;
     project: ProjectHandlerHost;
     community: CommunityHandlerHost;
-    settings: SettingsHandlerHost;
     dream: DreamHandlerHost;
     turn: TurnControlHandlerHost;
     turnBaseline: TurnBaselineHandlerHost;

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

@@ -1,12 +1,10 @@
 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 { PermissionRuleEnginePort } from "../runtime/ports/index.js";
 export type { FileWatcher };
 export interface RuntimeWatcherBootstrapDeps {
     config: Record<string, unknown>;
     hooks: HookRegistry;
-    ruleEngine: PermissionRuleEnginePort;
     sessionId: string;
     currentFileWatcher: FileWatcher | null;
     log: AgentLogger;

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

@@ -13,7 +13,7 @@
  * set_config) — keeps working unchanged.
  */
 import type { SessionState } from "../runtime/session/session-state.js";
-import type { SessionLlmConfig } from "./acp-session-host.js";
+import type { MaterializedSessionProfile, SessionLlmConfig } from "./acp-session-host.js";
 export declare class SessionContext {
     /** Active session id (chatId for desktop; group key pattern for groups). */
     sessionId: string;
@@ -23,7 +23,9 @@ export declare class SessionContext {
     state: SessionState | null;
     /** Host-pinned per-session LLM config (session/set_config_option · set_model · /model).
      *  NEVER wiped by ModelRegistry churn — distinct from the DERIVED ResolvedAgentCache. */
-    llmConfig: SessionLlmConfig;
+    llmConfigBySession: Map<string, SessionLlmConfig>;
+    /** Gateway-materialized profiles are private to their ACP session. */
+    materializedProfiles: Map<string, MaterializedSessionProfile>;
     /** ACP session-level context supplement (_meta from session/new), inherited by every prompt.
      *  LEGACY per-connection singleton — kept for old-gateway fallback; multiplexed prompts read
      *  acpMetaBySession by sessionId instead. */

package/dist/types/cli/skill-invocation-service.d.ts

@@ -1,8 +1,10 @@
+import type { HostCapabilityClient } from "../transport/host-capability-client.js";
 export interface RunSkillInvocationParams {
     skillName: string;
     skillContent: string;
     userArgs?: string;
     skillDir?: string;
     sessionId?: string;
+    hostCapabilityClient: HostCapabilityClient;
 }
 export declare function runSkillInvocation(params: RunSkillInvocationParams): Promise<string>;

package/dist/types/cli/skill-tools-bootstrap.d.ts

@@ -1,6 +1,7 @@
 import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
 import type { MemoryLearningSink, PathService, ToolCatalog } from "../runtime/ports/index.js";
 import type { WorkspaceSkill } from "../skills/skill-system/skill-types.js";
+import type { HostCapabilityClient } from "../transport/host-capability-client.js";
 export interface SkillToolsBootstrapDeps {
     config: Record<string, unknown>;
     pathService: PathService;
@@ -10,6 +11,7 @@ export type SkillLearningMemorySink = MemoryLearningSink;
 export interface SkillToolsHost {
     getActiveProjectRoot(): string;
     getPluginSkills(): WorkspaceSkill[];
+    getHostCapabilityClient(): HostCapabilityClient | undefined;
     sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
     getMemoryLearningSink(): SkillLearningMemorySink | null;
     getMemoryUserId(): string;

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

@@ -1,3 +1,4 @@
+import type { HostCapabilityClient } from "../transport/host-capability-client.js";
 export interface SkillListEntry {
     id: string;
     name: string;
@@ -37,4 +38,4 @@ export interface SkillListEntry {
  * scope and whether it is active in the given project. Name-collisions cannot
  * occur (one directory per name in the store), so each skill appears once.
  */
-export declare function listSkillsForProject(projectRoot?: string): SkillListEntry[];
+export declare function listSkillsForProject(capability: HostCapabilityClient | undefined, projectRoot?: string): Promise<SkillListEntry[]>;