qlogicagent 2.18.6 → 2.18.8

package/dist/types/cli/acp-session-host.d.ts

@@ -3,6 +3,7 @@ import type { AcpSessionMeta } from "../protocol/wire/index.js";
 import { createMemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
 import type { SessionState } from "../runtime/session/session-state.js";
 import type { SessionHistoryCoordinator } from "./session-history-coordinator.js";
+import type { HostCapabilityClient } from "../transport/host-capability-client.js";
 /**
  * LLM config pinned on the session by the host (session/set_config_option /
  * session/set_model / the /model command). This is host-supplied INPUT — distinct
@@ -18,6 +19,14 @@ export interface SessionLlmConfig {
     apiKey?: string;
     baseUrl?: string;
 }
+export interface MaterializedSessionBinding extends SessionLlmConfig {
+    routing?: string;
+}
+/** Gateway-materialized session-private profile. apiKey exists in memory only. */
+export interface MaterializedSessionProfile {
+    bindings: Record<string, MaterializedSessionBinding>;
+    permissions: Record<string, unknown>;
+}
 export interface AcpSessionHost {
     /** Gateway-supplied per-session context (_meta from session/new).
      *  LEGACY fallback: a per-CONNECTION singleton overwritten by the last session/new — kept only
@@ -25,8 +34,10 @@ export interface AcpSessionHost {
     acpSessionMeta: AcpSessionMeta | null;
     /** Per-session gateway _meta（session/new 注册；prompt 按 sessionId 取，消除跨会话串扰）。 */
     acpSessionMetaBySession: Map<string, AcpSessionMeta>;
-    /** Host-pinned per-session LLM config; overlaid into every prompt's turn config. */
-    sessionLlmConfig: SessionLlmConfig;
+    /** Legacy per-option pins, keyed by session (never a connection singleton). */
+    sessionLlmConfigBySession: Map<string, SessionLlmConfig>;
+    /** F2 full gateway profile, keyed by session; secrets are memory-only. */
+    materializedSessionProfiles: Map<string, MaterializedSessionProfile>;
     currentHooks: HookRegistry | null;
     currentSessionId: string;
     memoryPrefetchState: ReturnType<typeof createMemoryPrefetchState>;
@@ -36,6 +47,7 @@ export interface AcpSessionHost {
     disposeSessionRuntime?(): void;
     enableIdleDream(): void;
     ensureDefaultProject(): void;
+    initializeHostProjectAuthority?(): Promise<void>;
     /**
      * Ensure the model-registry catalog (this.models) is hydrated from the owner profile +
      * built-in/llmrouter catalog. A spawned/headless qlogicagent only runs load() (bindings +
@@ -45,6 +57,7 @@ export interface AcpSessionHost {
      */
     ensureModelRegistryHydrated?(): Promise<void>;
     getActiveProjectRoot(): string;
+    getHostCapabilityClient?(): HostCapabilityClient | undefined;
     log(message: string): void;
     sendNotification(method: string, params: Record<string, unknown>): void;
     setActiveWorkdir(dir: string): void;

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

@@ -18,5 +18,6 @@ export interface BaseToolBootstrapDeps {
     } | null;
     getTaskScopeKey?(): string | undefined;
     getCurrentTurnId?(): string | undefined;
+    loadTunableOverrides?(): Promise<Record<string, unknown>>;
 }
 export declare function configureBaseToolBootstrap(deps: BaseToolBootstrapDeps): void;

package/dist/types/cli/community-skill-installer.d.ts

@@ -1,4 +1,5 @@
 import type { CommunityInstallResolution } from "../runtime/community/community-consent-client.js";
+import type { HostCapabilityClient } from "../transport/host-capability-client.js";
 export interface CommunityInstalledResource {
     resourceId: string;
     version: string;
@@ -10,5 +11,6 @@ export interface InstallCommunitySkillOptions {
     fetchFn?: typeof fetch;
     /** Replace an existing install in place (update flow) instead of erroring. */
     allowReplace?: boolean;
+    hostCapabilityClient?: Pick<HostCapabilityClient, "prepareSkillInstall" | "finalizeSkillInstall">;
 }
 export declare function installCommunitySkillResource(install: CommunityInstallResolution, options?: InstallCommunitySkillOptions): Promise<CommunityInstalledResource>;

package/dist/types/cli/core-tool-coordinator.d.ts

@@ -3,6 +3,8 @@ import type { HookRegistry } from "../contracts/hooks.js";
 import type { BackgroundTaskManager } from "../runtime/infra/background-tasks.js";
 import type { ToolCatalog } from "../runtime/ports/index.js";
 import type { LLMTransport } from "./provider-core-facade.js";
+import type { HostProfileClient } from "../transport/host-profile-client.js";
+import type { HostCapabilityClient } from "../transport/host-capability-client.js";
 export interface CliCoreToolHostDeps {
     getAgent(): unknown | null;
     getCurrentTransport(): LLMTransport | null;
@@ -28,6 +30,8 @@ export interface CliCoreToolHostDeps {
         };
     }): void;
     handleMcpToolCall(memberId: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    getHostProfileClient?(): HostProfileClient | undefined;
+    getHostCapabilityClient?(): HostCapabilityClient | undefined;
 }
 export interface CliCoreToolCoordinatorDeps {
     config: Record<string, unknown>;

package/dist/types/cli/core-tools/config-tool-bootstrap.d.ts

@@ -1,5 +1,7 @@
 import type { ToolCatalog } from "../../runtime/ports/index.js";
+import type { HostProfileClient } from "../../transport/host-profile-client.js";
 export interface ConfigToolRegistrationDeps {
     toolCatalog: ToolCatalog;
+    resolveHostProfileClient?: () => HostProfileClient | undefined;
 }
-export declare function registerConfigTool({ toolCatalog }: ConfigToolRegistrationDeps): void;
+export declare function registerConfigTool({ toolCatalog, resolveHostProfileClient }: ConfigToolRegistrationDeps): void;

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

@@ -1,11 +1,13 @@
 /**
- * Config tool service — backs the `config` tool onto the REAL tunables system
- * (settings.tunables.*), the same store the UI settings page manages via the
- * config.updateTunable RPC. ModelRegistry.getTunable() re-reads settings.json
- * per call, so every write here is hot — no restart needed.
+ * Config tool service — a thin compute-side proxy over the gateway-owned tunable store.
+ *
+ * Defaults/coercion/validation come from the public qlogicagent/tunables contract. Persistent
+ * overrides are read and mutated only through HostProfileClient's private X7 profile service.
+ * The agent never reads or writes settings.json and has no local fallback.
  */
 import type { ConfigToolDeps } from "../../skills/tools/config-tool.js";
+import type { HostProfileClient } from "../../transport/host-profile-client.js";
 export interface ConfigToolServiceOptions {
-    settingsPath?: string;
+    resolveHostProfileClient?: () => HostProfileClient | undefined;
 }
 export declare function createConfigToolService(options?: ConfigToolServiceOptions): ConfigToolDeps;

package/dist/types/cli/default-project-bootstrap.d.ts

@@ -20,6 +20,7 @@ export interface DefaultProjectBootstrapDeps {
 interface DeferredHeavyWork {
     /** A default project was freshly created this run → its starter templates still need seeding. */
     freshDefaultDir?: string;
+    hostOwned?: boolean;
 }
 /** Resolves once the most recently scheduled deferred heavy work has settled (never rejects). */
 export declare function getDefaultProjectHeavyWorkPromise(): Promise<void>;

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

@@ -5,10 +5,11 @@
  *          agents.kill, agents.listConfigured, agents.getLog, agents.testConnection
  */
 import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
-import { AgentProcessManager } from "../../runtime/infra/agent-process.js";
+import type { 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";
 import { type PooledTurnCtx } from "../../runtime/infra/external-agent-pool.js";
+import type { DelegateBridge } from "../../orchestration/delegation-coordinator.js";
 export interface AgentsHandlerHost {
     acpDetector: AcpDetector;
     soloProcessManager: AgentProcessManager | null;
@@ -19,6 +20,8 @@ export interface AgentsHandlerHost {
     log?(message: string): void;
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
     sendNotification?(method: string, params: Record<string, unknown>): void;
+    /** 激活层(S3c §1.1):gateway-routed delegate 桥(懒读;未挂/gate 关 = undefined → 旧进程池路径)。 */
+    getDelegateBridge?(): DelegateBridge | undefined;
 }
 export declare function relayPooledTurnNotification(input: {
     agentId: string;

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

@@ -1,8 +1,10 @@
 import { type CommunityConsentClient } from "../../runtime/community/community-consent-client.js";
 import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
+import type { HostCapabilityClient } from "../../transport/host-capability-client.js";
 export type { CommunityConsentClient, CommunityInstallRiskTier, CommunityInstallResolution, } from "../../runtime/community/community-consent-client.js";
 export interface CommunityHandlerHost {
     resolveCommunityConsentClient?: () => CommunityConsentClient | null;
+    getHostCapabilityClient?(): HostCapabilityClient | undefined;
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
     /** Push a JSON-RPC notification (e.g. pet.asset.updated after a community pet install hydrates the UI store). */
     sendNotification(method: string, params: Record<string, unknown>): void;

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/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,9 +3,10 @@
  * 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";
+export { isStructuredPlannerSystemPrompt } from "../../contracts/structured-planner.js";
 import type { AppendMessageOutcome } from "../../runtime/session/session-transcript-store.js";
 import type { PermissionMetadataResolver, ToolCatalog } from "../../runtime/ports/index.js";
 import type { ChatMessage, TokenUsage, ToolDefinition, TurnConfig } from "../../agent/types.js";
@@ -98,9 +99,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 +143,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;
@@ -213,4 +228,3 @@ export interface TurnPipelineResult {
  * Invoked with `.call(host, input)` by the standard-ACP `session/prompt` handler.
  */
 export declare function runTurnPipeline(this: any, input: TurnPipelineInput): Promise<TurnPipelineResult>;
-export {};

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

@@ -15,3 +15,17 @@
  * 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>;