qlogicagent 2.20.2 → 2.20.4

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

@@ -27,6 +27,12 @@ export interface ArtifactContractState {
         artifactRoot: boolean;
     };
 }
+export type UiAcceptanceEvidenceSource = "browser_automation" | "frontend_test" | "user_confirmation" | "external_benchmark" | "fork_verify";
+export interface UiAcceptanceEvidence {
+    source: UiAcceptanceEvidenceSource;
+    status: "passed" | "failed";
+    summary: string;
+}
 export interface ArtifactContractEventPayload {
     artifactRoot?: string;
     writePaths: string[];
@@ -113,7 +119,9 @@ export declare function updateArtifactContractFromToolResult(params: {
     rawArguments: string;
     ok: boolean;
     content: string;
+    details?: Record<string, unknown>;
 }): void;
+export declare function recordUiAcceptanceEvidence(state: ArtifactContractState, evidence: UiAcceptanceEvidence): void;
 export declare function artifactContractPayload(state: ArtifactContractState, inputMessages: readonly ChatMessage[]): ArtifactContractEventPayload;
 export declare function recoverArtifactContractState(inputMessages: readonly ChatMessage[]): ArtifactContractState;
 export declare function updateArtifactContractFromFinalContent(state: ArtifactContractState, content: string): void;

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

@@ -78,6 +78,11 @@ export interface ToolLoopParams {
      * the next LLM call, steering the run without waiting for the turn to finish.
      */
     drainPendingGuidance?: () => string[];
+    /**
+     * Drain session-scoped, bounded background-task results. Each update becomes
+     * system context between rounds; the model never needs to busy-poll.
+     */
+    drainPendingTaskNotifications?: () => string[];
     /**
      * Sanitize a tool-result message's media the MAIN model can't consume (e.g. the `read` tool
      * returning an image for a text-only model → provider closes the stream, -32603): route it to

package/dist/types/agent/types.d.ts

@@ -93,6 +93,11 @@ export interface TurnRequest {
      * tool-loop round; returned strings become user messages before the next LLM call.
      */
     drainPendingGuidance?: () => string[];
+    /**
+     * Drain bounded background-task results for this session. Consulted between
+     * rounds so completed sub-agents can rejoin the parent without model polling.
+     */
+    drainPendingTaskNotifications?: () => string[];
     /**
      * Route media a tool returns that the MAIN model can't consume (e.g. `read` returning an image
      * for a text-only model) to the understanding model; folds the description into the message text

package/dist/types/cli/acp-extended-handlers.d.ts

@@ -25,6 +25,11 @@ export interface AcpExtendedHost extends DreamHandlerHost, SoloHandlerHost, Prod
         resolve: (answers: Record<string, string> | null) => void;
     }>;
 }
+interface GatewayProjectContext {
+    projectId: string;
+    canonicalSessionId: string;
+    cwd: string;
+}
 export declare function handleAcpDream(host: AcpExtendedHost, params: {
     sessionId: string;
     config?: Record<string, unknown>;
@@ -41,6 +46,7 @@ export declare function handleAcpDream(host: AcpExtendedHost, params: {
 export declare function handleAcpSoloStart(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpSoloSelect(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpSoloCancel(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpSoloDelete(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpSoloSubscribe(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpSoloMessage(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpSoloEvaluate(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
@@ -56,9 +62,8 @@ export declare function handleAcpSoloSpecChat(host: AcpExtendedHost, params: Rec
  */
 export declare function handleAcpSoloSpecJudge(host: AcpExtendedHost, params: Record<string, unknown>): Promise<SoloSpecJudgeResult>;
 /**
- * M4 自动化页对话式搭图/改图(x/workflow.chat):forked agent + propose_workflow 工具,产出工作流提案
- * (新建 def / 改已有 patch),propose-only 无副作用。澄清走 Cut6 ask 往返。失败降级 { error } 不抛。
- * 应用由前端经 Gateway Host workflow.create/patch 完成(触发 WS 回流画布),故本轮无持久化副作用。
+ * 自动化页对话式搭图/改图:Agent 只提交有界 operations，确定性编译器产出唯一 proposal。
+ * 本计算面无持久化副作用；Runtime Host 是 proposal 的唯一校验和应用者。
  */
 export declare function handleAcpWorkflowChat(host: AcpExtendedHost, params: Record<string, unknown>): Promise<WorkflowChatResult>;
 /**
@@ -79,20 +84,17 @@ export declare function handleAcpProductRollback(host: AcpExtendedHost, params:
 export declare function handleAcpProductReplay(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 /** Test-only reset. */
 export declare function __resetGoalHandler(): void;
+export declare function goalLeaderMemberOwner(context: GatewayProjectContext): string;
 export declare function handleAcpGoalStart(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpGoalPause(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpGoalResume(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpGoalUpdateGoal(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpGoalStop(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpGoalMessage(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
-/** Test-only reset. */
-export declare function __resetSubscribers(): void;
-/** I6: drop a session from every stream's subscriber set on disconnect (called from session/close),
- *  pruning sets that become empty so the registry doesn't leak entries for dead sessions. */
-export declare function removeSessionSubscriptions(sessionId: string): void;
-export declare function emitGoalNotification(_streamId: string, method: string, payload: Record<string, unknown>, hosts: {
+export declare function emitGoalNotification(method: string, payload: Record<string, unknown>, hosts: {
     currentSessionId?: string;
     sendNotification: (m: string, p: Record<string, unknown>) => void;
 }[]): void;
 export declare function handleAcpGoalSubscribe(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpProductSubscribe(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export {};

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

@@ -45,4 +45,4 @@ export declare function handleAcpSessionSetModel(host: AcpSessionHost, _sessionI
  * Returns the applied modeId; the server emits current_mode_update. An unknown mode throws a coded
  * error which the acp-server dispatch translates into a JSON-RPC error.
  */
-export declare function handleAcpSessionSetMode(host: AcpSessionHost, _sessionId: string, modeId: string): Promise<string>;
+export declare function handleAcpSessionSetMode(host: AcpSessionHost, sessionId: string, modeId: string): Promise<string>;

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

@@ -46,10 +46,18 @@ export interface AcpSessionHost {
     sessionState: SessionState | null;
     cancelIdleDreamTimer(): void;
     disposeSessionRuntime?(): void;
+    /** Retire only the named session's in-memory permission checker/rules/hooks. */
+    disposeSessionPermissions?(sessionId: string): void;
     /** Dispose only the named canonical session's MCP manager and tool overlay. */
     disposeSessionMcp?(sessionId: string): Promise<void>;
     /** Bind async turn work to a canonical session without consulting a mutable process-global pointer. */
     runInSessionScope?<T>(sessionId: string, action: () => Promise<T>): Promise<T>;
+    /** Enter only an already-known session; cancellation must not recreate closed state. */
+    runInExistingSessionScope?<T>(sessionId: string, action: () => Promise<T>): Promise<T | undefined>;
+    /** Reserve foreground priority before asynchronous project/model preparation starts. */
+    beginForegroundTurn?(): void;
+    /** Release a foreground-priority reservation on every terminal path. */
+    endForegroundTurn?(): void;
     enableIdleDream(): void;
     ensureDefaultProject(): void | Promise<void>;
     initializeHostProjectAuthority?(): Promise<void>;

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

@@ -10,6 +10,8 @@ import type { McpManager } from "../skills/mcp/mcp-manager.js";
 import type { PluginLoader } from "../skills/plugins/plugin-loader.js";
 import type { CliAgentClient } from "./cli-agent-builder.js";
 import { type CliCoreToolHostDeps } from "./core-tool-coordinator.js";
+import { type PermissionBootstrapDeps } from "./permission-bootstrap.js";
+import type { RuntimePermissionRuleEngine } from "./permission-runtime-service.js";
 import type { LLMTransport } from "./provider-core-facade.js";
 import { type FileWatcher } from "./runtime-watcher-bootstrap.js";
 export type { FileWatcher };
@@ -22,6 +24,7 @@ export interface AgentRuntimeBootstrapDeps {
     getTurnId(): string;
     projectRoot: string;
     pathService: PathService;
+    getActiveWorkdir?: () => string;
     memdir: ProjectMemoryStore;
     getMemdir?: () => ProjectMemoryStore | null;
     currentUserId: string;
@@ -33,6 +36,7 @@ export interface AgentRuntimeBootstrapDeps {
         apiKey: string;
         model: string;
     } | null;
+    scheduleBackgroundMemoryWork(label: string, work: (signal: AbortSignal) => Promise<void>): Promise<boolean>;
     agentClient: CliAgentClient;
     toolCatalog: ToolCatalog;
     currentMcpManager: McpManager | null;
@@ -50,7 +54,8 @@ export interface AgentRuntimeBootstrapDeps {
         }>;
     } | undefined;
     sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
-    currentPermissionUnregister?: (() => void) | null;
+    existingPermissionRuleEngine?: RuntimePermissionRuleEngine;
+    resolveSandboxPermissionSnapshot?: PermissionBootstrapDeps["resolveSandboxPermissionSnapshot"];
     coreToolHost: CliCoreToolHostDeps;
     toolInvoker: ToolInvoker;
     currentFileWatcher: FileWatcher | null;
@@ -64,5 +69,6 @@ export interface AgentRuntimeBootstrapResult {
     permissionChecker: PermissionMetadataResolver;
     permissionUnregister: () => void;
     ruleEngine: PermissionRuleEnginePort;
+    groupSecurityActive?: boolean;
 }
 export declare function configureAgentRuntimeBootstrap(deps: AgentRuntimeBootstrapDeps): AgentRuntimeBootstrapResult;

package/dist/types/cli/agent-runtime-session-state.d.ts

@@ -1,20 +1,35 @@
 import type { HookRegistry } from "../contracts/hooks.js";
-import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, PermissionMetadataResolver, ToolCatalog } from "../runtime/ports/index.js";
+import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, PermissionMetadataResolver, PermissionRuleEnginePort, 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 { AgentRuntimeBootstrapResult, FileWatcher } from "./agent-runtime-bootstrap.js";
+export interface PermissionState {
+    permissionChecker: PermissionMetadataResolver;
+    permissionUnregister: () => void;
+    ruleEngine: PermissionRuleEnginePort;
+    groupSecurityActive: boolean;
+}
+export interface SessionRuntimeState {
+    hooks: HookRegistry;
+    permission: PermissionState;
+}
 export declare class AgentRuntimeSessionState {
-    currentHooks: HookRegistry | null;
+    private readonly runtimeBySession;
+    private readonly permissionLeaseCountBySession;
+    private readonly retiredPermissionUnregisterBySession;
     private readonly mcpBySession;
     pluginLoader: PluginLoader | null;
-    permissionChecker: PermissionMetadataResolver | null;
-    permissionUnregister: (() => void) | null;
     fileWatcher: FileWatcher | null;
     memoryProvider: MemoryHandlerProvider | null;
     memoryDreamProvider: MemoryDreamRuntimeProvider | null;
     memoryUserId: string;
     getPluginSkills(): ReturnType<PluginLoader["getPluginSkills"]>;
-    applyBootstrap(result: AgentRuntimeBootstrapResult): void;
+    applyBootstrap(sessionId: string, result: AgentRuntimeBootstrapResult): void;
+    withPermissionLease<T>(sessionId: string, action: () => Promise<T>): Promise<T>;
+    getHooks(sessionId: string): HookRegistry | null;
+    getPermissionState(sessionId: string): PermissionState | undefined;
+    getRuntimeState(sessionId: string): SessionRuntimeState | undefined;
+    getPermissionUnregister(sessionId: string): (() => void) | null;
     resetAfterSessionDispose(): void;
     stopFileWatcher(): void;
     getMcpToolCatalog(sessionId: string, baseCatalog: ToolCatalog): ToolCatalog;
@@ -26,7 +41,9 @@ export declare class AgentRuntimeSessionState {
     setMcpConfigKey(sessionId: string, baseCatalog: ToolCatalog, configKey: string): void;
     disconnectMcp(sessionId: string): Promise<void>;
     disconnectAllMcp(): Promise<void>;
-    unregisterPermissions(): void;
+    unregisterPermissions(sessionId?: string): void;
     resetMemoryProviders(): void;
     private ensureMcpSession;
+    private retirePermissionUnregister;
+    private flushRetiredPermissionUnregisters;
 }

package/dist/types/cli/atomic-text-file.d.ts

@@ -0,0 +1,31 @@
+import type { TextFileFormat, TextFileSnapshot, TextFileWriteOptions } from "../skills/tools/file-text-snapshot.js";
+export interface StreamedTextWindow {
+    type: "text_window";
+    text: string;
+    totalLines?: number;
+    startLine: number;
+    endLine: number;
+    hasMore: boolean;
+    fileSizeBytes: number;
+    scannedBytes: number;
+    contentHash?: string;
+    metadataComplete: boolean;
+    truncatedByBytes: boolean;
+}
+export declare class ConcurrentFileModificationError extends Error {
+    readonly code = "ECONCURRENT";
+    constructor(filePath: string);
+}
+export declare function hashFileBytes(filePath: string): Promise<string>;
+export declare function hashFileBytesSync(filePath: string): string;
+export declare function readTextSnapshot(filePath: string): Promise<TextFileSnapshot>;
+export declare function atomicWriteText(filePath: string, content: string, options?: TextFileWriteOptions): Promise<{
+    contentHash: string;
+    format: TextFileFormat;
+}>;
+export declare function readTextWindow(filePath: string, options: {
+    offset: number;
+    limit: number;
+    maxBytes: number;
+    scanToEnd?: boolean;
+}): Promise<StreamedTextWindow>;

package/dist/types/cli/background-context-capsule.d.ts

@@ -0,0 +1,12 @@
+import type { ChatMessage } from "../agent/types.js";
+export interface BackgroundContextCapsuleOptions {
+    activeProjectRoot: string;
+    redactSensitive: boolean;
+    maxChars?: number;
+}
+/**
+ * Build a bounded parent-state handoff for a background fork. This deliberately
+ * excludes full assistant prose and hidden reasoning while preserving the state
+ * a worker commonly needs to avoid rediscovery.
+ */
+export declare function buildBackgroundContextCapsule(history: readonly ChatMessage[] | null | undefined, options: BackgroundContextCapsuleOptions): string;

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

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

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

@@ -4,11 +4,13 @@ import * as acpExtended from "./acp-extended-handlers.js";
 import * as acpSession from "./acp-session-handlers.js";
 export interface CliAcpRequestHandlerHost extends acpSession.AcpSessionHost {
     activeTurn: AbortController | null;
+    turnDone?: Promise<void>;
     /** Id of the turn currently running; used to key cancel requests. */
     currentTurnId?: string;
     permissionChecker?: PermissionApprovalResolver | null;
     /** LH-10: propagate an explicit cancel to the background tasks the given (or
      *  current) session launched. No-op if the host has no task registry. */
-    cancelBackgroundTasksForSession?(sessionId?: string): void;
+    cancelBackgroundTasksForSession?(sessionId?: string, parentTurnId?: string): void;
+    scheduleBackgroundMemoryWork(label: string, work: (signal: AbortSignal) => Promise<void>): Promise<boolean>;
 }
 export declare function createCliAcpRequestHandler(host: CliAcpRequestHandlerHost, packageVersion: string, extendedHost?: acpExtended.AcpExtendedHost): AcpRequestHandler;

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

@@ -19,7 +19,7 @@ export interface CommunityWorkflowBundlePayload {
     version: string;
     sourceTier: string;
     riskTier: string;
-    /** The sanitized WorkflowBundle JSON (schemaVersion 2) — feed to workflow.import. */
+    /** The sanitized WorkflowBundle JSON (current schemaVersion) — feed to workflow.import. */
     bundle: Record<string, unknown>;
     manifest: unknown;
 }

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

@@ -13,6 +13,7 @@ export interface CliCoreToolHostDeps {
     getCurrentModel(): string;
     getCurrentBaseUrl(): string;
     getCurrentSessionId(): string;
+    getCurrentTurnId?(): string | undefined;
     getActiveProjectRoot(): string;
     getVerbose(): boolean;
     getBackgroundTasks(): BackgroundTaskManager | null;

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

@@ -1,9 +1,10 @@
 import type { AgentLogger, ToolInvoker } from "../../agent/types.js";
 import type { HookRegistry } from "../../contracts/hooks.js";
 import type { ChatMessage } from "../../agent/types.js";
+import { type ForkedAgentResult } from "../../runtime/execution/forked-agent.js";
 import type { BackgroundTaskManager } from "../../runtime/infra/background-tasks.js";
 import type { ToolCatalog } from "../../runtime/ports/index.js";
-import type { AgentToolDeps } from "../../skills/tools/agent-tool.js";
+import type { AgentResult, AgentToolDeps } from "../../skills/tools/agent-tool.js";
 import type { LLMTransport } from "../provider-core-facade.js";
 export interface AgentToolServiceHost {
     readonly agent: unknown | null;
@@ -37,4 +38,19 @@ export interface AgentToolServiceOptions {
     toolCatalog: ToolCatalog;
     toolInvoker: ToolInvoker;
 }
+export declare function extractForkLifecycleSummary(result: ForkedAgentResult): {
+    resultSummary?: string;
+    evidence: Array<{
+        source: "tool" | "artifact" | "verification";
+        label: string;
+        status: "passed" | "failed" | "observed";
+    }>;
+    toolsUsed: string[];
+    tokenUsage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+};
+export declare function extractForkUiAcceptanceEvidence(result: ForkedAgentResult): NonNullable<AgentResult["uiAcceptanceEvidence"]>;
 export declare function createAgentToolService({ host, hooks, log, toolCatalog, toolInvoker }: AgentToolServiceOptions): AgentToolDeps;

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

@@ -1,7 +1,8 @@
-import type { PathService, ToolCatalog } from "../runtime/ports/index.js";
+import type { ToolCatalog } from "../runtime/ports/index.js";
 export interface DevToolBootstrapDeps {
     config: Record<string, unknown>;
-    pathService?: PathService;
+    /** Immutable project root resolved for the canonical session/turn. */
+    workdir: string;
     toolCatalog: ToolCatalog;
 }
 export declare const devToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<DevToolBootstrapDeps>;

package/dist/types/cli/dev-tools/dev-tool-bootstrap-service.d.ts

@@ -1,6 +1,7 @@
 import type { ToolCatalog } from "../../runtime/ports/index.js";
 export interface DevToolBootstrapServiceDeps {
     workdir: string;
+    config?: Record<string, unknown>;
     toolCatalog: ToolCatalog;
 }
 export declare function registerDevTools(deps: DevToolBootstrapServiceDeps): void;

package/dist/types/cli/dev-tools/dev-tool-registry.d.ts

@@ -1,6 +1,8 @@
 import { createLspTool } from "../../skills/tools/lsp-tool.js";
+import { createRepoMapTool } from "../../skills/tools/repo-map-tool.js";
 export interface DevToolRegistryOptions {
     workdir: string;
+    config?: Record<string, unknown>;
 }
-export type DevTool = ReturnType<typeof createLspTool>;
+export type DevTool = ReturnType<typeof createRepoMapTool> | ReturnType<typeof createLspTool>;
 export declare function buildDevTools(options: DevToolRegistryOptions): DevTool[];

package/dist/types/cli/dev-tools/incremental-repo-map.d.ts

@@ -0,0 +1,81 @@
+import type { RepoMapQuery, RepoMapResult } from "../../skills/tools/repo-map-tool.js";
+export type RepoMapChangeType = "created" | "modified" | "deleted";
+export interface RepoMapWatcher {
+    on(event: "error", listener: (error: Error) => void): RepoMapWatcher;
+    close(): void;
+}
+export type RepoMapWatchFactory = (root: string, options: {
+    recursive: true;
+    persistent: false;
+}, listener: (eventType: "rename" | "change", filename: string | Buffer | null) => void) => RepoMapWatcher;
+export interface IncrementalRepoMapOptions {
+    workspaceRoot: string;
+    maxFileBytes?: number;
+    maxIndexedFiles?: number;
+    maxTotalBytes?: number;
+    maxScanMs?: number;
+    maxDepth?: number;
+    idleTimeoutMs?: number;
+    now?: () => number;
+    watch?: boolean;
+    watchFactory?: RepoMapWatchFactory;
+}
+export declare class IncrementalRepoMap {
+    private readonly workspaceRoot;
+    private readonly maxFileBytes;
+    private readonly maxIndexedFiles;
+    private readonly maxTotalBytes;
+    private readonly maxScanMs;
+    private readonly maxDepth;
+    private readonly idleTimeoutMs;
+    private readonly now;
+    private readonly watchEnabled;
+    private readonly watchFactory;
+    private readonly abortController;
+    private workspaceRealPathPromise?;
+    private readonly pending;
+    private files;
+    private watcher?;
+    private watcherReliable;
+    private watcherWarning?;
+    private nextWatchRetryAt;
+    private forceFullRequested;
+    private initialized;
+    private generation;
+    private indexPartial;
+    private indexWarning?;
+    private disposed;
+    private refreshPromise?;
+    private activeQueries;
+    private idleTimer?;
+    constructor(options: IncrementalRepoMapOptions);
+    markChanged(filePath: string, changeType?: RepoMapChangeType): void;
+    getMap(query?: RepoMapQuery): Promise<RepoMapResult>;
+    releaseIdleResources(): void;
+    dispose(): void;
+    private beginQuery;
+    private finishQuery;
+    private scheduleIdleRelease;
+    private clearIdleTimer;
+    private tryStartWatcher;
+    private invalidateWatcher;
+    private maybeRebuildWatcher;
+    private refresh;
+    private runRefresh;
+    private applyIncrementalWithFallback;
+    private applyIncremental;
+    private buildFullIndex;
+    private scanDirectory;
+    private loadPath;
+    private createScanBudget;
+    private checkScanTime;
+    private reserveIndexedFile;
+    private stopScan;
+    private commitFullIndex;
+    private canonicalPathInsideWorkspace;
+    private getWorkspaceRealPath;
+    private throwIfAborted;
+    private takePending;
+    private restorePending;
+    private toRelativePath;
+}

package/dist/types/cli/dev-tools/lsp-supervisor.d.ts

@@ -0,0 +1,59 @@
+import { type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { LspOperation, LspResult } from "../../skills/tools/lsp-tool.js";
+export interface LspServerDefinition {
+    id: string;
+    command: string;
+    args?: readonly string[];
+    extensions: readonly string[];
+    languageId: string | ((filePath: string) => string);
+    env?: NodeJS.ProcessEnv;
+}
+export interface LspSpawnOptions {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    stdio: ["pipe", "pipe", "pipe"];
+    shell: false;
+    windowsHide: true;
+}
+export type LspSpawnFactory = (command: string, args: readonly string[], options: LspSpawnOptions) => ChildProcessWithoutNullStreams;
+export interface LspSupervisorOptions {
+    serverDefinitions: readonly LspServerDefinition[];
+    spawn?: LspSpawnFactory;
+    requestTimeoutMs?: number;
+    shutdownTimeoutMs?: number;
+    idleTimeoutMs?: number;
+    stderrTailBytes?: number;
+    diagnosticSettleMs?: number;
+}
+export interface LspSupervisorOperationParams {
+    workspaceRoot: string;
+    operation: LspOperation;
+    filePath: string;
+    line?: number;
+    character?: number;
+    newName?: string;
+    includeContext?: boolean;
+}
+export interface LspSupervisor {
+    executeOperation(params: LspSupervisorOperationParams, signal?: AbortSignal): Promise<LspResult>;
+    supportedLanguages(): string[];
+    dispose(): Promise<void>;
+}
+export type LspSupervisorErrorCode = "LSP_SERVER_NOT_CONFIGURED" | "LSP_PATH_OUTSIDE_WORKSPACE" | "LSP_DIAGNOSTICS_UNAVAILABLE" | "LSP_FILE_TOO_LARGE" | "LSP_SUPERVISOR_DISPOSED" | "LSP_PROCESS_ERROR" | "LSP_PROCESS_EXIT" | "LSP_PROTOCOL_ERROR" | "LSP_REQUEST_ABORTED" | "LSP_REQUEST_TIMEOUT" | "LSP_RESPONSE_ERROR";
+export interface LspErrorDiagnostics {
+    serverId?: string;
+    command?: string;
+    pid?: number;
+    exitCode?: number | null;
+    signal?: NodeJS.Signals | null;
+    stderrTail?: string;
+    method?: string;
+    data?: unknown;
+}
+export declare class LspSupervisorError extends Error {
+    readonly code: LspSupervisorErrorCode;
+    readonly diagnostics: LspErrorDiagnostics;
+    constructor(code: LspSupervisorErrorCode, message: string, diagnostics?: LspErrorDiagnostics);
+}
+export declare function buildDefaultLspServerDefinitions(): LspServerDefinition[];
+export declare function createLspSupervisor(options: LspSupervisorOptions): LspSupervisor;

package/dist/types/cli/dev-tools/lsp-tool-service.d.ts

@@ -1,5 +1,7 @@
 import type { LspToolDeps } from "../../skills/tools/lsp-tool.js";
+import type { LspSupervisor } from "./lsp-supervisor.js";
 export interface LspToolServiceOptions {
     workdir: string;
+    supervisor?: LspSupervisor;
 }
 export declare function createLspToolDeps(options: LspToolServiceOptions): LspToolDeps;

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

@@ -1,10 +1,12 @@
 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";
+import type { HostCommunityClient } from "../../transport/host-community-client.js";
 export type { CommunityConsentClient, CommunityInstallRiskTier, CommunityInstallResolution, } from "../../runtime/community/community-consent-client.js";
 export interface CommunityHandlerHost {
     resolveCommunityConsentClient?: () => CommunityConsentClient | null;
     getHostCapabilityClient?(): HostCapabilityClient | undefined;
+    getHostCommunityClient?(): HostCommunityClient | undefined;
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
 }
 export declare function handleCommunityResolveInstall(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;

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

@@ -31,7 +31,7 @@ export interface DreamHandlerHost {
     sendNotification(method: string, params: Record<string, unknown>): void;
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
 }
-export declare function handleDream(this: DreamHandlerHost, msg: AgentRpcRequest): Promise<void>;
+export declare function handleDream(this: DreamHandlerHost, msg: AgentRpcRequest, parentSignal?: AbortSignal): Promise<void>;
 /**
  * [B15] dream 后置维护三链:importance decay → 冲突消解/待定 claim 晋升 → 提案消费。
  * 每次 dream 尝试后运行(不看 dream 成败;调用点见 handleDream),三链彼此错误隔离 ——

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

@@ -1,11 +1,6 @@
-/**
- * Agent-resident memory brain-compute handlers. Handles: memory.propose (LLM candidate
- * extraction) and memory.search (hybrid retrieval with a memdir fallback). The store/library
- * and memdir file-face methods are Runtime Host-native (gateway MemoryProfileService + memdir
- * file face) and were removed here — see rpc-registry.memory-cut.test.ts.
- */
+/** Agent-resident proposal extraction and the canonical Host-backed long-term search adapter. */
 import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
-import type { MemoryHandlerProvider, ProjectMemoryStore, ProjectMemoryStoreFactory } from "../../runtime/ports/index.js";
+import type { MemoryHandlerProvider } from "../../runtime/ports/index.js";
 import { type MemoryModelPurpose } from "../memory-candidate-service.js";
 interface MemoryLlmClient {
     model: string;
@@ -18,17 +13,10 @@ interface MemoryLlmClient {
     };
 }
 export interface MemoryHandlerHost {
-    memdir: ProjectMemoryStore | null;
     memoryProvider?: MemoryHandlerProvider | null;
     memoryUserId?: string;
-    projectMemoryStoreFactory: ProjectMemoryStoreFactory;
-    projectLocator?: {
-        resolveProjectRoot(projectId: string): string | undefined;
-    };
     ensureMemoryProvider?(): void;
-    getActiveProjectRoot(): string;
     resolveClientForPurpose?(purpose: MemoryModelPurpose): MemoryLlmClient | null;
-    sendNotification(method: string, params: Record<string, unknown>): void;
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
 }
 export declare function handleMemoryPropose(this: MemoryHandlerHost, msg: AgentRpcRequest): Promise<void>;

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

@@ -1,9 +1,12 @@
 /**
- * Product mode handlers.
- * Handles: product.plan/confirm/message/create/resume/pause/checkpoint/list/delete/cancel/rollback/replay.
+ * Product mode glue.
+ *
+ * The ACP surface (`x/product.*`) lives in `acp-extended-handlers.ts` and is the only Product entry
+ * point the Gateway routes to. This module keeps the pieces that surface shares: the coordinator
+ * accessors, the host type, and the phase-agnostic cancel.
  */
 import type { ProductPlanningOwner } from "../../orchestration/product-planner.js";
-import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
+import type { AgentRpcError } from "../../protocol/wire/index.js";
 import { type ProductCoordinatorHost } from "../product-coordinator.js";
 export type { ProductCoordinatorHost } from "../product-coordinator.js";
 export interface ProductHandlerHost extends ProductCoordinatorHost {
@@ -13,21 +16,6 @@ export interface ProductHandlerHost extends ProductCoordinatorHost {
 export { writeProductProjectPlanStatus } from "../product-coordinator.js";
 export declare function ensureProductOrchestrator(this: ProductCoordinatorHost): import("../../orchestration/agent-instance.js").ProductOrchestrator;
 export declare function ensureProductPlanner(this: ProductCoordinatorHost): import("../../orchestration/product-planner.js").ProductPlanner;
-/** `product.plan` - Start interactive planning with leader agent. */
-export declare function handleProductPlan(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
-/** `product.confirm` - User confirms the plan, transition to execution. */
-export declare function handleProductConfirm(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
-/** `product.message` - User sends message to leader (multi-turn planning or execution intervention). */
-export declare function handleProductMessage(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
-/** `product.create` - Create a new Product Mode session. */
-export declare function handleProductCreate(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
-/** `product.resume` - Resume a paused product. */
-export declare function handleProductResume(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
-/** `product.pause` - Pause a running product. */
-export declare function handleProductPause(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
-/** `product.checkpoint` - Manual checkpoint. */
-export declare function handleProductCheckpoint(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleProductDelete(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
 /**
  * Cancel a product no matter which lifecycle phase it is in. The orchestrator only knows
  * POST-confirm (executing) sessions; while the leader is still PLANNING, the product lives in
@@ -45,9 +33,3 @@ export declare function cancelProductAnyPhase(orchestrator: {
 }, planner: {
     cancel(productId: string, owner: ProductPlanningOwner): Promise<void>;
 }, productId: string, owner: ProductPlanningOwner): Promise<void>;
-/** `product.cancel` - Cancel a running product (handles both executing and planning phases). */
-export declare function handleProductCancel(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
-/** `product.rollback` - Rollback a product to a checkpoint. */
-export declare function handleProductRollback(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
-/** `product.replay` - Re-run from an arbitrary completed/failed task forward, reusing upstream outputs. */
-export declare function handleProductReplay(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;