qlogicagent 2.20.1 → 2.20.3

package/dist/types/cli/idle-dream-coordinator.d.ts

@@ -17,23 +17,23 @@ export interface IdleDreamCoordinatorOptions {
     randomId?: () => string;
     timers?: IdleDreamTimers;
     log(message: string): void;
-    sendNotification(method: string, params: Record<string, unknown>): void;
     getCurrentSessionId(): string;
     getCurrentTurnCount(): number;
-    getActiveTurn(): AbortController | null;
+    hasForegroundTurn(): boolean;
     resolveDreamClient(): IdleDreamClient | null;
     resolveMemoryRoot(): string;
     resolveTranscriptDir(): string;
     listRecentSessions(): Promise<Array<{
         sessionId: string;
     }>>;
-    runDream(message: AgentRpcRequest): Promise<void>;
+    runDream(message: AgentRpcRequest, signal: AbortSignal): Promise<void>;
+    runBackgroundWork(label: string, work: (signal: AbortSignal) => Promise<void>): Promise<boolean>;
     /**
      * Optional idle-time hook run on every idle fire BEFORE the dream gates (so it is not blocked by
      * dream cooldown / missing LLM transport). Used for the feedback redaction+upload sweep
      * (design §9 item 5). Errors are swallowed so a sweep failure never breaks dream.
      */
-    onIdle?(): Promise<void>;
+    onIdle?(signal: AbortSignal): Promise<void>;
 }
 export declare class IdleDreamCoordinator {
     private readonly options;
@@ -42,12 +42,16 @@ export declare class IdleDreamCoordinator {
     private readonly randomId;
     private readonly timers;
     private idleTimer;
+    private idleCycle;
+    private idleDreamTurnId;
     constructor(options: IdleDreamCoordinatorOptions);
     applyEnvOverrides(env: Record<string, string | undefined>): void;
     enable(minutes?: number): void;
-    handleTurnNotification(method: string): void;
+    handleTurnNotification(method: string, params?: Record<string, unknown>): void;
+    yieldToForegroundTurn(): void;
     cancelTimer(): void;
     resetTimer(): void;
     triggerIdleDream(): Promise<void>;
+    private runIdleDreamCycle;
 }
 export {};

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

@@ -0,0 +1,26 @@
+export type MemoryBackgroundWork = (signal: AbortSignal) => Promise<void>;
+export interface MemoryBackgroundCoordinatorOptions {
+    defaultTimeoutMs?: number;
+    idleCycleTimeoutMs?: number;
+    maxTimeoutRetries?: number;
+}
+/**
+ * One process-wide lane for memory learning work. Foreground turns have strict
+ * priority: they abort active work and queued jobs resume serially afterwards.
+ */
+export declare class MemoryBackgroundCoordinator {
+    private readonly log;
+    private foregroundReservations;
+    private active;
+    private readonly queue;
+    private nextSequence;
+    private readonly defaultTimeoutMs;
+    private readonly idleCycleTimeoutMs;
+    private readonly maxTimeoutRetries;
+    constructor(log?: (message: string) => void, options?: MemoryBackgroundCoordinatorOptions);
+    beginForegroundTurn(): void;
+    endForegroundTurn(): void;
+    schedule(label: string, work: MemoryBackgroundWork): Promise<boolean>;
+    private enqueue;
+    private drain;
+}

package/dist/types/cli/memory-candidate-service.d.ts

@@ -14,10 +14,9 @@ export interface MemoryCandidateHost {
     memoryProvider?: {
         search?(query: string, userId: string, options?: {
             limit?: number;
-            minScore?: number;
         }): Promise<Array<{
-            blockId: string;
-            text: string;
+            id: string;
+            content: string;
             score?: number;
             metadata?: Record<string, unknown>;
         }>>;

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

@@ -2,15 +2,16 @@ import { type HostRequestRequester } from "../skills/memory/host-memory-provider
 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";
-import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, MemoryLearningSink, MemoryProvider, MemoryRuntimeHookProvider, MemoryToolProvider, ProjectMemoryStore, ToolCatalog } from "../runtime/ports/index.js";
+import type { MemoryDreamRuntimeProvider, MemoryExtractionQueue, MemoryHandlerProvider, MemoryLearningSink, MemoryProvider, MemoryRuntimeHookProvider, MemoryToolProvider, ProjectMemoryStore, ToolCatalog } from "../runtime/ports/index.js";
 import type { LLMTransport } from "./provider-core-facade.js";
 export interface MemoryProviderState {
-    recallProvider: MemoryProvider | null;
-    runtimeHookProvider: MemoryRuntimeHookProvider | null;
-    learningSink: MemoryLearningSink | null;
-    toolProvider: MemoryToolProvider | null;
-    handlerProvider: MemoryHandlerProvider | null;
-    dreamProvider: MemoryDreamRuntimeProvider | null;
+    recallProvider: MemoryProvider;
+    runtimeHookProvider: MemoryRuntimeHookProvider;
+    learningSink: MemoryLearningSink;
+    toolProvider: MemoryToolProvider;
+    handlerProvider: MemoryHandlerProvider;
+    dreamProvider: MemoryDreamRuntimeProvider;
+    extractionQueue: MemoryExtractionQueue;
     userId: string;
 }
 /** Host-request access exposed by the ACP protocol coordinator. */
@@ -18,7 +19,7 @@ export interface MemoryHostRequestAccess {
     supportsHostRequestService(service: "memory"): boolean;
     readonly hostRequest: HostRequestRequester;
 }
-/** 装配期绑定(stdio-runtime-services 注入;lazy resolver——gate 在创建时刻现读)。重绑重置选型护栏。 */
+/** 装配期绑定(stdio-runtime-services 注入;lazy resolver——gate 在创建时刻现读)。 */
 export declare function bindMemoryHostRequestAccess(resolve: () => MemoryHostRequestAccess | null): void;
 export declare function ensureHostMemoryProvider(currentUserId: string): MemoryProviderState;
 export interface RegisterMemoryRuntimeHooksDeps {
@@ -33,6 +34,7 @@ export interface RegisterMemoryRuntimeHooksDeps {
         apiKey: string;
         model: string;
     } | null;
+    scheduleBackgroundMemoryWork(label: string, work: (signal: AbortSignal) => Promise<void>): Promise<boolean>;
     /** Part B recall visibility: forwards turn.memory_recall to the client. */
     sendNotification?: (method: string, params: Record<string, unknown>) => void;
 }
@@ -42,6 +44,8 @@ export interface RegisterMemoryToolDeps {
     getMemdir?: () => ProjectMemoryStore;
     memoryProvider: MemoryToolProvider | null;
     memoryUserId: string;
+    sessionId?: string;
+    getTurnId?: () => string;
     toolCatalog: ToolCatalog;
     sendNotification?: (method: string, params: Record<string, unknown>) => void;
 }

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 SandboxPermissionSnapshot } from "./tool-bootstrap.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";
@@ -31,11 +32,19 @@ export interface PermissionBootstrapDeps {
     } | undefined;
     sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
     resolveHostProfileClient?: () => HostProfileClient | undefined;
-    currentUnregister?: (() => void) | null;
+    sessionPermissionStore?: {
+        loadAllowedDirectories(sessionId: string, projectRoot: string): string[];
+        appendAllowedDirectory(sessionId: string, projectRoot: string, pathPrefix: string): Promise<void>;
+    };
+    /** Existing session engine reused when an Agent is rebuilt for the same session. */
+    existingRuleEngine?: RuntimePermissionRuleEngine;
+    /** AsyncLocal-aware resolver supplied by the pooled stdio host. */
+    resolveSandboxPermissionSnapshot?: () => SandboxPermissionSnapshot | undefined;
 }
 export interface PermissionBootstrapResult {
     permissionChecker: RuntimePermissionChecker;
     permissionUnregister: () => void;
     ruleEngine: RuntimePermissionRuleEngine;
+    groupSecurityActive: boolean;
 }
 export declare function configurePermissionBootstrap(deps: PermissionBootstrapDeps): PermissionBootstrapResult;

package/dist/types/cli/product-acp-params.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Runtime validation for the `x/product.*` ACP write surface.
+ *
+ * Every product entry point casts with `params as unknown as XParams`, and the only fields anything
+ * actually checked were projectId / canonicalSessionId / cwd (via requireGatewayProjectContext).
+ * `instances`, `tasks`, `budget`, `productId` and `taskId` reached the orchestrator unvalidated, so a
+ * malformed frame surfaced far downstream — an empty assignee died at dispatch with
+ * `No instance found for assignee ""`, a missing prompt produced a task that could only fail, and a
+ * non-array `tasks` threw somewhere inside DagScheduler construction.
+ *
+ * Validate at the boundary and fail with an actionable message naming the offending field.
+ */
+/** `instances[]` — each needs a name (assignees reference it) and an agentId (the provider to spawn). */
+export declare function assertProductInstances(value: unknown, field?: string): void;
+/** `tasks[]` — taskId/assignee/prompt are all load-bearing at dispatch time. */
+export declare function assertProductTasks(value: unknown, field?: string): void;
+/** `budget` is optional, but a present one must carry usable numbers rather than silently doing nothing. */
+export declare function assertProductBudget(value: unknown, field?: string): void;
+export declare function assertProductId(params: Record<string, unknown>): string;
+export declare function assertProductTaskId(params: Record<string, unknown>): string;
+/**
+ * `x/product.create` — the orchestrator builds the DAG straight from these.
+ *
+ * `name` is deliberately NOT required here: existing callers omit it and the orchestrator derives a
+ * display name. Only the fields that cause a downstream failure are enforced.
+ */
+export declare function assertProductCreateParams(params: Record<string, unknown>): void;
+/** `x/product.confirm` — the user-edited final payload; same shape requirements as create. */
+export declare function assertProductConfirmParams(params: Record<string, unknown>): void;

package/dist/types/cli/resolved-agent-cache.d.ts

@@ -19,6 +19,7 @@
  */
 import type { Agent } from "../agent/agent.js";
 import type { LLMTransport } from "./provider-core-facade.js";
+import type { SessionRuntimeState } from "./agent-runtime-session-state.js";
 export interface ResolvedAgentSnapshot {
     agent: Agent;
     transport: LLMTransport;
@@ -27,6 +28,10 @@ export interface ResolvedAgentSnapshot {
     provider: string;
     baseUrl: string;
     configKey: string;
+    runtimeGeneration?: SessionRuntimeState;
+}
+export interface ResolvedAgentView extends Omit<ResolvedAgentSnapshot, "agent"> {
+    agent: Agent | null;
 }
 /**
  * ToolInvoker captures a session overlay at Agent construction, so equal provider/model settings
@@ -34,15 +39,21 @@ export interface ResolvedAgentSnapshot {
  */
 export declare function buildSessionAgentConfigKey(sessionId: string, resolvedConfigKey: string, mcpConfigKey?: string): string;
 export declare class ResolvedAgentCache {
-    agent: Agent | null;
-    transport: LLMTransport | null;
-    apiKey: string;
-    model: string;
-    provider: string;
-    baseUrl: string;
-    private configKey;
+    private readonly snapshotsByConfigKey;
+    private readonly latestConfigKeyBySession;
+    private lastConfigKey;
+    private get lastSnapshot();
+    get agent(): Agent | null;
+    get transport(): LLMTransport | null;
+    get apiKey(): string;
+    get model(): string;
+    get provider(): string;
+    get baseUrl(): string;
     /** True when a cached Agent matches the given resolved config key. */
     matches(configKey: string): boolean;
+    getRuntimeGeneration(configKey: string): SessionRuntimeState | undefined;
+    getForSession(sessionId: string): ResolvedAgentView | undefined;
+    get(configKey: string): ResolvedAgentView | undefined;
     /** Store the freshly resolved Agent + LLM client snapshot. */
     store(snapshot: ResolvedAgentSnapshot): void;
     /** Drop only the Agent + config key — force re-resolve, keep the last snapshot. */

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

@@ -30,7 +30,7 @@ export type RpcMethodHandler = (msg: AgentRpcRequest) => void | Promise<void>;
  * adapters, just applied uniformly across every RPC domain.
  */
 export interface TaskDistillationRpcSurface {
-    runPass(reason: "manual"): Promise<object>;
+    runPass(reason: "manual", signal?: AbortSignal): Promise<object>;
     listProposals(): Promise<unknown[]>;
     dismissProposal(id: string): Promise<boolean>;
     acknowledgeProposal(id: string): Promise<boolean>;
@@ -41,6 +41,7 @@ export interface TaskDistillationRpcSurface {
 export interface RpcHandlerHosts {
     /** R3/V3 蒸馏晋升面(惰性:首调时构造 coordinator)。 */
     getTaskDistillation?: () => TaskDistillationRpcSurface;
+    scheduleBackgroundMemoryWork(label: string, work: (signal: AbortSignal) => Promise<void>): Promise<boolean>;
     config: ConfigHandlerHost;
     control: ControlHandlerHost;
     session: SessionHandlerHost;

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

@@ -10,6 +10,7 @@ export interface RuntimeHookBootstrapDeps {
     taskStore: TaskStore;
     backgroundTasks: BackgroundTaskManager;
     sessionId: string;
+    getTurnId(): string;
     projectRoot: string;
     memdir: ProjectMemoryStore;
     getMemdir?: () => ProjectMemoryStore | null;
@@ -23,6 +24,7 @@ export interface RuntimeHookBootstrapDeps {
         apiKey: string;
         model: string;
     } | null;
+    scheduleBackgroundMemoryWork(label: string, work: (signal: AbortSignal) => Promise<void>): Promise<boolean>;
     compressionClient: {
         transport: LLMTransport;
         apiKey: string;

package/dist/types/cli/stdio-acp-request-host.d.ts

@@ -8,7 +8,7 @@ import type { CliAcpRequestHandlerHost } from "./cli-acp-request-handler.js";
  * (`this: any`), so members it touches must be forwarded here explicitly;
  * see TURN_PIPELINE_HOST_MEMBERS for the regression-tested list.
  */
-export type StdioAcpRequestHostSource = Pick<CliAcpRequestHandlerHost, "activeTurn" | "acpSessionMeta" | "acpSessionMetaBySession" | "currentHooks" | "currentSessionId" | "currentTurnId" | "memoryPrefetchState" | "permissionChecker" | "sessionHistory" | "sessionLlmConfigBySession" | "materializedSessionProfiles" | "sessionState" | "cancelIdleDreamTimer" | "disposeSessionRuntime" | "disposeSessionMcp" | "runInSessionScope" | "enableIdleDream" | "ensureDefaultProject" | "initializeHostProjectAuthority" | "ensureModelRegistryHydrated" | "getActiveProjectRoot" | "log" | "sendNotification" | "setActiveWorkdir"> & {
+export type StdioAcpRequestHostSource = Pick<CliAcpRequestHandlerHost, "activeTurn" | "turnDone" | "acpSessionMeta" | "acpSessionMetaBySession" | "currentHooks" | "currentSessionId" | "currentTurnId" | "memoryPrefetchState" | "permissionChecker" | "sessionHistory" | "sessionLlmConfigBySession" | "materializedSessionProfiles" | "sessionState" | "cancelIdleDreamTimer" | "disposeSessionRuntime" | "disposeSessionPermissions" | "disposeSessionMcp" | "runInSessionScope" | "runInExistingSessionScope" | "beginForegroundTurn" | "endForegroundTurn" | "enableIdleDream" | "ensureDefaultProject" | "initializeHostProjectAuthority" | "ensureModelRegistryHydrated" | "getActiveProjectRoot" | "log" | "sendNotification" | "setActiveWorkdir"> & {
     currentModel: string | undefined;
     lastAssistantMessageForExtract: string | undefined;
     lastUserMessageForAutoExtract: string | undefined;
@@ -18,7 +18,9 @@ export type StdioAcpRequestHostSource = Pick<CliAcpRequestHandlerHost, "activeTu
     projectMemoryStoreFactory: unknown;
     toolCatalog: unknown;
     taskDistillation: unknown;
-    cancelBackgroundTasksForSession(sessionId?: string): void;
+    cancelBackgroundTasksForSession(sessionId?: string, parentTurnId?: string): void;
+    beginTurnRequest(): number;
+    isTurnRequestCurrent(generation: number): boolean;
     configureTurnMedia(config: Record<string, unknown> | undefined, turnId: string): void;
     getAcpPermissionSession(): {
         sessionId: string;
@@ -27,12 +29,13 @@ export type StdioAcpRequestHostSource = Pick<CliAcpRequestHandlerHost, "activeTu
         }>;
     } | undefined;
     getHostRequestClient(): Pick<HostRequestClient, "request"> | undefined;
-    drainPendingTaskNotifications(): string[];
+    drainPendingTaskNotifications(sessionId: string): string[];
     resolveAgent(config: unknown, projectRoot?: string): unknown;
     resolveClientForPurpose(purpose: unknown): unknown;
+    scheduleBackgroundMemoryWork(label: string, work: (signal: AbortSignal) => Promise<void>): Promise<boolean>;
     sendResponse(id: string | number, result?: unknown, error?: unknown): void;
 };
 /** Host members the shared turn pipeline reads/writes — keep in sync with
  * `grep -oE "this\.[a-zA-Z]+" src/cli/handlers/turn-handler.ts | sort -u`. */
-export declare const TURN_PIPELINE_HOST_MEMBERS: readonly ["activeTurn", "configureTurnMedia", "currentHooks", "currentModel", "currentTurnId", "drainPendingTaskNotifications", "getAcpPermissionSession", "getHostRequestClient", "getActiveProjectRoot", "lastAssistantMessageForExtract", "lastUserMessageForAutoExtract", "log", "mcpReady", "memdir", "pendingAskUser", "permissionChecker", "projectMemoryStoreFactory", "resolveAgent", "resolveClientForPurpose", "sendNotification", "sendResponse", "sessionHistory", "sessionState", "setActiveWorkdir", "taskDistillation", "toolCatalog"];
+export declare const TURN_PIPELINE_HOST_MEMBERS: readonly ["activeTurn", "turnDone", "beginForegroundTurn", "beginTurnRequest", "configureTurnMedia", "currentHooks", "currentModel", "currentTurnId", "isTurnRequestCurrent", "drainPendingTaskNotifications", "endForegroundTurn", "getAcpPermissionSession", "getHostRequestClient", "getActiveProjectRoot", "lastAssistantMessageForExtract", "lastUserMessageForAutoExtract", "log", "mcpReady", "memdir", "pendingAskUser", "permissionChecker", "projectMemoryStoreFactory", "resolveAgent", "resolveClientForPurpose", "scheduleBackgroundMemoryWork", "sendNotification", "sendResponse", "sessionHistory", "sessionState", "setActiveWorkdir", "taskDistillation", "toolCatalog"];
 export declare function createStdioAcpRequestHandlerHost(host: StdioAcpRequestHostSource): CliAcpRequestHandlerHost;

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

@@ -15,6 +15,7 @@ import type { ResolvedTextGenerationConfig } from "./model-client-resolver.js";
 import type { LLMTransport, ProviderRegistry } from "./provider-core-facade.js";
 import type { MediaPersistence } from "../runtime/infra/media-persistence.js";
 import type { FileWatcher } from "./agent-runtime-bootstrap.js";
+import type { SandboxPermissionSnapshot } from "./tool-bootstrap.js";
 export interface StdioAgentSessionBootstrapDeps {
     config: Record<string, unknown> & {
         maxRounds?: number;
@@ -27,6 +28,7 @@ export interface StdioAgentSessionBootstrapDeps {
     getTurnId(): string;
     projectRoot: string;
     pathService: PathService;
+    getActiveWorkdir?: () => string;
     memdir: ProjectMemoryStore;
     getMemdir?: () => ProjectMemoryStore | null;
     currentUserId: string;
@@ -38,14 +40,17 @@ export interface StdioAgentSessionBootstrapDeps {
         apiKey: string;
         model: string;
     } | null;
+    scheduleBackgroundMemoryWork(label: string, work: (signal: AbortSignal) => Promise<void>): Promise<boolean>;
     providerRegistry: ProviderRegistry;
     mediaPersistence: MediaPersistence;
     toolCatalog: ToolCatalog;
     runtimeSession: {
-        permissionUnregister: (() => void) | null;
         fileWatcher: FileWatcher | null;
         getPluginSkills(): ReturnType<PluginLoader["getPluginSkills"]>;
-        applyBootstrap(result: {
+        getPermissionState(sessionId: string): {
+            ruleEngine: PermissionRuleEnginePort;
+        } | undefined;
+        applyBootstrap(sessionId: string, result: {
             hooks: HookRegistry;
             memoryHandlerProvider: MemoryHandlerProvider | null;
             memoryDreamProvider: MemoryDreamRuntimeProvider | null;
@@ -63,6 +68,7 @@ export interface StdioAgentSessionBootstrapDeps {
     setMcpConfigKey(configKey: string): void;
     setPluginLoader(loader: PluginLoader): void;
     setFileWatcher(watcher: FileWatcher | null): void;
+    resolveSandboxPermissionSnapshot?(): SandboxPermissionSnapshot | undefined;
     getAcpPermissionSession(): {
         sessionId: string;
         requestPermission(params: AcpPermissionRequestParams): Promise<{

package/dist/types/cli/stdio-rpc-handler-hosts.d.ts

@@ -1,19 +1,21 @@
 import type { LLMRequest } from "../agent/types.js";
 import type { ModelPurpose } from "../runtime/infra/model-registry.js";
+import type { ProjectMemoryStore, ProjectMemoryStoreFactory } from "../runtime/ports/index.js";
 import type { MultiAgentHandlerHost } from "./multi-agent-handler-host.js";
 import type { RpcHandlerHosts } from "./rpc-registry.js";
 type DirectStdioRpcHost = RpcHandlerHosts["config"] & RpcHandlerHosts["control"] & RpcHandlerHosts["files"] & RpcHandlerHosts["skills"] & RpcHandlerHosts["community"] & {
     currentTurnId?: string;
     /** Mid-turn guidance queue (运行中引导) — shared between handleTurnGuide and the tool loop's drain. */
     pendingTurnGuidance?: string[];
-    memdir: RpcHandlerHosts["memory"]["memdir"];
-    projectMemoryStoreFactory: RpcHandlerHosts["memory"]["projectMemoryStoreFactory"];
+    memdir: ProjectMemoryStore | null;
+    projectMemoryStoreFactory: ProjectMemoryStoreFactory;
     setActiveWorkdir(dir: string): void;
     getActiveProjectRoot(): string;
     readonly multiAgentHandlerHost: MultiAgentHandlerHost;
 };
 type StdioRpcAdapterSource = DirectStdioRpcHost & {
     ensureTaskDistillation(): import("./rpc-registry.js").TaskDistillationRpcSurface;
+    scheduleBackgroundMemoryWork(label: string, work: (signal: AbortSignal) => Promise<void>): Promise<boolean>;
     activeTurn: RpcHandlerHosts["turn"]["activeTurn"];
     currentSessionId: NonNullable<RpcHandlerHosts["session"]["currentSessionId"]>;
     currentModel: NonNullable<RpcHandlerHosts["session"]["currentModel"]>;

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

@@ -9,6 +9,7 @@ export interface StdioRuntimeBootstrapDeps {
     getActiveProjectRoot(): string;
     getCurrentSessionId?(): string | undefined;
     getCurrentTurnId?(): string | undefined;
+    isGroupSecurityMode?(): boolean;
     resolveClientForPurpose(purpose: ModelPurpose): {
         transport: LLMTransport;
         apiKey: string;

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

@@ -20,7 +20,6 @@ import { BackgroundTaskManager } from "../runtime/infra/background-tasks.js";
 import { type AgentRpcError } from "../protocol/wire/index.js";
 import type { AcpServer } from "../transport/acp-server.js";
 import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
-import { AgentRuntimeSessionState } from "./agent-runtime-session-state.js";
 import { type MultiAgentHandlerHost } from "./multi-agent-handler-host.js";
 import { SessionHistoryCoordinator } from "./session-history-coordinator.js";
 import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, PermissionMode, ProjectMemoryStore } from "../runtime/ports/index.js";
@@ -41,15 +40,16 @@ export declare class StdioServer {
     private rpc;
     /** Gateway contract — exposed for control-handler metrics/cancel. */
     get rpcContract(): import("../protocol/wire/gateway-contract.js").GatewayRpcContract;
-    activeTurn: AbortController | null;
+    private connectionActiveTurn;
     /** Resolves when the active turn fully completes (including post-abort flush). */
-    private turnDone;
+    private connectionTurnDone;
     verbose: boolean;
     private transport;
     private readonly runtimeServices;
     private readonly runtimeSession;
     /** Canonical ACP session captured for the full async turn; never inferred from a mutable pointer. */
     private readonly sessionScope;
+    private readonly executionBySession;
     /**
      * DERIVED resolved-agent cache (Agent + LLM client snapshot). The invalidation
      * invariant (full wipe on registry change vs forget-agent on session dispose)
@@ -63,18 +63,23 @@ export declare class StdioServer {
     taskStore: TaskStore;
     /** Unified background execution registry (agent forks + backgrounded shell commands). */
     backgroundTasks: BackgroundTaskManager;
-    /** Settled-task notifications queued for injection into the next turn's context. */
-    private pendingTaskNotifications;
+    /** Settled-task notifications isolated by their launching session. */
+    private readonly pendingTaskNotificationsBySession;
     /** Session-scoped memory prefetch state (LRU dedup + byte limit). */
-    memoryPrefetchState: MemoryPrefetchState;
+    private connectionMemoryPrefetchState;
     /** Last user message text for auto-extract hook (set at turn start, cleared at turn end).
      * Public: the turn pipeline writes it through the ACP host adapter. */
-    lastUserMessageForAutoExtract: string | undefined;
+    private connectionLastUserMessageForAutoExtract;
     /** Last assistant message text for implicit extraction hook (set at turn end).
      * Public: the turn pipeline writes it through the ACP host adapter. */
-    lastAssistantMessageForExtract: string | undefined;
+    private connectionLastAssistantMessageForExtract;
+    private connectionPendingTurnGuidance;
+    private connectionRequestGeneration;
+    /** Foreground reservations begin before async routing, closing the idle-timer race. */
+    private foregroundTurnCount;
+    private readonly memoryBackground;
     /** MEMDIR file-based memory (CC memdir parity). */
-    memdir: ProjectMemoryStore | null;
+    private connectionMemdir;
     readonly projectMemoryStoreFactory: import("../runtime/ports/project-memory-store.js").ProjectMemoryStoreFactory;
     /** Memory write gate state (P2+P3: category gate + supersedes). */
     /** Pending ask_user requests waiting for host response */
@@ -96,6 +101,7 @@ export declare class StdioServer {
     get toolCatalog(): import("../runtime/ports/tool-contracts.js").ToolCatalog;
     /** Turn pipeline awaits this before tool dispatch (MCP servers connected). */
     get mcpReady(): Promise<void>;
+    private get activeResolvedAgent();
     private get agent();
     /** Cached LLM transport for sub-agent forks (dream). */
     get currentTransport(): LLMTransport | null;
@@ -106,9 +112,33 @@ export declare class StdioServer {
     get currentSessionId(): string;
     set currentSessionId(v: string);
     private activeScopedSessionId;
+    private activeScopedWorkdir;
+    private activeScopedRuntimeState;
+    private isActiveGroupSecurityMode;
+    private bindCachedRuntimeGeneration;
+    private createSessionExecutionState;
+    private getOrCreateSessionExecutionState;
+    private runWithSessionExecutionScope;
     runInSessionScope<T>(sessionId: string, action: () => Promise<T>): Promise<T>;
+    runInExistingSessionScope<T>(sessionId: string, action: () => Promise<T>): Promise<T | undefined>;
+    get activeTurn(): AbortController | null;
+    set activeTurn(value: AbortController | null);
+    get turnDone(): Promise<void>;
+    set turnDone(value: Promise<void>);
     get currentTurnId(): string;
     set currentTurnId(v: string);
+    beginTurnRequest(): number;
+    isTurnRequestCurrent(generation: number): boolean;
+    get sessionState(): SessionState | null;
+    set sessionState(v: SessionState | null);
+    get memoryPrefetchState(): MemoryPrefetchState;
+    set memoryPrefetchState(v: MemoryPrefetchState);
+    get memdir(): ProjectMemoryStore | null;
+    set memdir(v: ProjectMemoryStore | null);
+    get lastUserMessageForAutoExtract(): string | undefined;
+    set lastUserMessageForAutoExtract(v: string | undefined);
+    get lastAssistantMessageForExtract(): string | undefined;
+    set lastAssistantMessageForExtract(v: string | undefined);
     /**
      * The active ACP permission session for the current turn, or undefined when no host is connected.
      */
@@ -135,22 +165,21 @@ export declare class StdioServer {
      * Declared as a real field so the proxy in createTurnHost has a shared backing store
      * (turn pipeline and handleTurnGuide must see the SAME array).
      */
-    pendingTurnGuidance: string[];
+    get pendingTurnGuidance(): string[];
+    set pendingTurnGuidance(v: string[]);
     /** LH-10: an explicit cancel of a session stops the background tasks that
      *  session launched — the forked agent + the exec processes it spawned —
      *  instead of leaving them running as zombies. Keyed by session id, which is
      *  shared across the client/agent boundary (turn ids are not). */
-    cancelBackgroundTasksForSession(sessionId?: string): void;
-    get sessionState(): SessionState | null;
-    set sessionState(v: SessionState | null);
+    cancelBackgroundTasksForSession(sessionId?: string, parentTurnId?: string): void;
     get sessionLlmConfigBySession(): Map<string, import("./acp-session-host.js").SessionLlmConfig>;
     get materializedSessionProfiles(): Map<string, import("./acp-session-host.js").MaterializedSessionProfile>;
     get acpSessionMeta(): Record<string, unknown> | null;
     set acpSessionMeta(v: Record<string, unknown> | null);
     get acpSessionMetaBySession(): Map<string, Record<string, unknown>>;
     get currentHooks(): import("../contracts/hooks.js").HookRegistry | null;
-    get permissionChecker(): AgentRuntimeSessionState["permissionChecker"];
-    private set permissionChecker(value);
+    get permissionChecker(): import("../runtime/ports/permission-contracts.js").PermissionMetadataResolver | null;
+    private resolveSandboxPermissionSnapshot;
     /**
      * config.update 权限热应用:写盘的同时立即更新活的 rule engine,
      * 当前会话(乃至运行中 turn)的下一次工具调用就按新模式判定——
@@ -177,7 +206,7 @@ export declare class StdioServer {
      * Called by the turn pipeline at turn start — settled tasks are injected
      * into the model's context as <task_notification> blocks.
      */
-    drainPendingTaskNotifications(): string[];
+    drainPendingTaskNotifications(sessionId: string): string[];
     ensureModelRegistryHydrated(): Promise<void>;
     syncToolListMediaConfig(): void;
     configureTurnMedia(config: Record<string, unknown> | undefined, turnId: string): void;
@@ -250,8 +279,12 @@ export declare class StdioServer {
      * Enable idle dream scheduling. Called after session setup when LLM config is available.
      */
     enableIdleDream(minutes?: number): void;
+    beginForegroundTurn(): void;
+    endForegroundTurn(): void;
+    scheduleBackgroundMemoryWork(label: string, work: (signal: AbortSignal) => Promise<void>): Promise<boolean>;
     cancelIdleDreamTimer(): void;
     disposeSessionRuntime(): void;
+    disposeSessionPermissions(sessionId: string): void;
     disposeSessionMcp(sessionId: string): Promise<void>;
     /**
      * Initialize the ACP server alongside the legacy protocol.

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

@@ -1,12 +1,10 @@
 import { type MemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
 import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider } from "../runtime/ports/index.js";
 import type { AgentRuntimeSessionState } from "./agent-runtime-session-state.js";
-import type { ResolvedAgentCache } from "./resolved-agent-cache.js";
 import type { StdioRuntimeServices } from "./stdio-runtime-services.js";
 export interface StdioSessionRuntimeCoordinatorDeps {
     runtimeSession: AgentRuntimeSessionState;
     runtimeServices: Pick<StdioRuntimeServices, "closeMemoryProviders">;
-    resolvedAgent: Pick<ResolvedAgentCache, "forgetAgent">;
     getMemoryProvider(): MemoryHandlerProvider | null;
     getMemoryDreamProvider(): MemoryDreamRuntimeProvider | null;
     setMemoryPrefetchState(state: MemoryPrefetchState): void;