qlogicagent 2.24.1 → 2.24.2

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

@@ -1,29 +0,0 @@
-/**
- * Community WORKFLOW install (IT-5, spec D35/D23): download the published package, verify
- * size+checksum against registry metadata, gunzip, and parse the SANITIZED WorkflowBundle.
- *
- * Deliberately NOTHING lands on disk here: a workflow bundle is a declarative graph, not an
- * executable artifact — applying it goes through the same `workflow.import` write path every
- * other bundle uses (validateWorkflowDef gate, project-scoped persistence, and external
- * connection reconfiguration in node/MCP settings). This function only fetches + verifies + parses.
- *
- * NOT the executable launcher-gate path: bundles carry no code; they run inside the engine's
- * restricted expression language under the D29/D30 permission gates, and applying one never
- * activates it (activation requires publish + the unattended grant door).
- */
-import type { CommunityInstallResolution } from "../runtime/community/community-consent-client.js";
-export interface CommunityWorkflowBundlePayload {
-    kind: "workflow";
-    mode: "bundle";
-    resourceId: string;
-    version: string;
-    sourceTier: string;
-    riskTier: string;
-    /** The sanitized WorkflowBundle JSON (current schemaVersion) — feed to workflow.import. */
-    bundle: Record<string, unknown>;
-    manifest: unknown;
-}
-export interface InstallCommunityWorkflowOptions {
-    fetchFn?: typeof fetch;
-}
-export declare function installCommunityWorkflowResource(install: CommunityInstallResolution, options?: InstallCommunityWorkflowOptions): Promise<CommunityWorkflowBundlePayload>;

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

@@ -1,12 +0,0 @@
-import type { NotificationMethodMap } from "../protocol/notifications.js";
-import type { PathService, ProjectMemoryStore, ProjectMemoryStoreFactory } from "../runtime/ports/index.js";
-export interface DefaultProjectBootstrapDeps {
-    pathService: PathService;
-    projectMemoryStoreFactory: ProjectMemoryStoreFactory;
-    sendNotification<M extends keyof NotificationMethodMap>(method: M, params: NotificationMethodMap[M]): void;
-}
-/**
- * Bind compute state to the active Host project. The Gateway must already have
- * hydrated the Project snapshot; qlogicagent never creates or repairs projects.
- */
-export declare function ensureDefaultProjectBootstrap(deps: DefaultProjectBootstrapDeps): Promise<ProjectMemoryStore>;

package/dist/types/cli/dream-host-adapter.d.ts

@@ -1,24 +0,0 @@
-import type { TurnConfig } from "../agent/types.js";
-import type { AgentRpcError } from "../protocol/wire/index.js";
-import type { DreamHandlerHost } from "./handlers/dream-handler.js";
-export interface DreamHostAdapterDeps {
-    getActiveTurn(): AbortController | null;
-    setActiveTurn(value: AbortController | null): void;
-    getCurrentTransport(): DreamHandlerHost["currentTransport"];
-    getCurrentApiKey(): string;
-    getCurrentModel(): string;
-    getCurrentHooks(): DreamHandlerHost["currentHooks"];
-    getMemoryProvider(): DreamHandlerHost["memoryProvider"];
-    getMemoryUserId(): string;
-    ensureMemoryProvider(): void;
-    getToolCatalog(): DreamHandlerHost["toolCatalog"];
-    getTaskStore(): DreamHandlerHost["taskStore"];
-    getVerbose(): boolean;
-    log(message: string): void;
-    resolveMemoryRoot(): string;
-    resolveTranscriptDir(): string;
-    resolveAgent(config: TurnConfig): unknown | null;
-    sendNotification(method: string, params: Record<string, unknown>): void;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-}
-export declare function createDreamHostAdapter(deps: DreamHostAdapterDeps): DreamHandlerHost;

package/dist/types/cli/gateway-rpc-connection.d.ts

@@ -1,50 +0,0 @@
-/**
- * GatewayRpcConnection — the JSON-RPC request lifecycle for the gateway contract.
- *
- * Owns the per-request bookkeeping: the gateway contract (dedup/settle/expire), the
- * in-flight request ledger (id → meta), and the deadline timers; plus the wire-side
- * response builders. Extracted from StdioServer to separate its "protocol routing"
- * concern from its "runtime state container" concern — StdioServer keeps the
- * transport, message dispatch, and ACP routing, and delegates the request-lifecycle
- * mechanics here through thin sendResponse/sendError methods.
- *
- * It does NOT own the transport: the raw frame writer is injected via `write`, so the
- * server stays in charge of transport ownership / start / close / ACP routing.
- *
- * Covered by stdio-server.contract.test.ts (contract gate, dedup, deadline expiry,
- * late-response drop).
- */
-import { GatewayRpcContract, type AgentRpcError, type AgentRpcRequest } from "../protocol/wire/index.js";
-export interface GatewayRpcConnectionDeps {
-    /** Raw transport send — writes one JSON-RPC frame to the wire. */
-    write: (msg: unknown) => void;
-    log: (message: string) => void;
-}
-export declare class GatewayRpcConnection {
-    private readonly contract;
-    private readonly inflight;
-    private readonly deadlineTimers;
-    private readonly write;
-    private readonly log;
-    constructor(deps: GatewayRpcConnectionDeps);
-    /** The gateway contract — exposed for control-handler metrics/cancel. */
-    get rpcContract(): GatewayRpcContract;
-    /** True while a request id is in flight (no response settled yet). */
-    hasInFlight(id: string | number): boolean;
-    /**
-     * Run the gateway contract gate for an inbound request (caller guarantees the
-     * id is present and the method is not meta-optional). Returns true if the caller
-     * should dispatch; false if the request was rejected/deduped — in which case a
-     * response has already been written.
-     */
-    begin(id: string | number, msg: AgentRpcRequest): boolean;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-    /** Convenience over sendResponse for handlers that build the error inline. */
-    sendError(id: string | number, code: AgentRpcError["code"], message: string, data?: unknown): void;
-    /** Clear the in-flight ledger + deadline timers (server shutdown). */
-    dispose(): void;
-    private clearLifecycle;
-    private sendContractError;
-    private sendContractErrorOrResult;
-    private scheduleDeadline;
-}

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

@@ -1,14 +0,0 @@
-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>;
-export declare function handleCommunityListResourceVersions(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleCommunityInstallResource(this: CommunityHandlerHost, msg: AgentRpcRequest): Promise<void>;

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

@@ -1,19 +0,0 @@
-/**
- * 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 { BackgroundTaskManager } from "../../runtime/infra/background-tasks.js";
-import type { TaskStore } from "../../runtime/infra/task-runtime.js";
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-export interface ConfigHandlerHost {
-    taskStore: TaskStore;
-    backgroundTasks: BackgroundTaskManager;
-    toolCatalog?: ToolCatalog;
-    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 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/control-handler.d.ts

@@ -1,29 +0,0 @@
-import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
-import type { NotificationMethodMap } from "../../protocol/notifications.js";
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-export interface ControlHandlerHost {
-    running: boolean;
-    startedAt: number;
-    packageVersion: string;
-    toolCatalog: ToolCatalog;
-    activeTurn: AbortController | null;
-    rpcContract: {
-        metrics(): unknown;
-        cancel(requestId: string, reason?: string): boolean;
-    };
-    log(message: string): void;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-    sendNotification<M extends keyof NotificationMethodMap>(method: M, params: NotificationMethodMap[M]): void;
-    ensureDefaultProject(): void | Promise<void>;
-    /** LH-10: propagate an explicit cancel to the background tasks the current
-     *  session launched. No-op if the host has no task registry. */
-    cancelBackgroundTasksForSession?(sessionId?: string): void;
-    /** Actual registered RPC method names (single source of truth = the live registry), so the
-     *  initialize capability declaration never drifts from what's really handled. */
-    getRegisteredMethods(): string[];
-}
-export declare function handleInitialize(this: ControlHandlerHost, msg: AgentRpcRequest): void;
-export declare function handlePing(this: ControlHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleHealth(this: ControlHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleMetrics(this: ControlHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleCancel(this: ControlHandlerHost, msg: AgentRpcRequest): void;

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

@@ -1,41 +0,0 @@
-/**
- * Dream/memory consolidation handler — extracted from StdioServer.
- * Handles: memory.dream
- */
-import type { TurnConfig } from "../../agent/types.js";
-import type { AgentRpcError, AgentRpcRequest } from "../../protocol/wire/index.js";
-import { type DreamRunDeps } from "../../runtime/execution/dream-agent.js";
-import { type DecayCycleDeps } from "../../runtime/execution/memory-decay.js";
-import type { TaskStore } from "../../runtime/infra/task-runtime.js";
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-type DreamMemoryProvider = NonNullable<DreamRunDeps["memoryProvider"]> & DecayCycleDeps["adapter"];
-export interface DreamHandlerHost {
-    activeTurn?: AbortController | null;
-    currentTransport: DreamRunDeps["transport"] | null;
-    currentApiKey: string;
-    currentModel: string;
-    currentHooks?: DreamRunDeps["hooks"] | null;
-    memoryProvider?: DreamMemoryProvider | null;
-    memoryUserId?: string;
-    /** Lazy read-path init for the L2 memory provider (cheap, side-effect-free DB open). Consumers
-     *  that can run before any turn (goal planning's orchestration memory context, memory.atlas)
-     *  must call this before reading memoryProvider — on a cold process nothing else has built it. */
-    ensureMemoryProvider?(): void;
-    toolCatalog: ToolCatalog;
-    taskStore: TaskStore;
-    verbose?: boolean;
-    log(message: string): void;
-    resolveMemoryRoot?(): string;
-    resolveTranscriptDir?(): string;
-    resolveAgent(config: TurnConfig): unknown | null;
-    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, parentSignal?: AbortSignal): Promise<void>;
-/**
- * [B15] dream 后置维护三链:importance decay → 冲突消解/待定 claim 晋升 → 提案消费。
- * 每次 dream 尝试后运行(不看 dream 成败;调用点见 handleDream),三链彼此错误隔离 ——
- * 任一链失败只留 error 级日志,不阻断后续链。导出仅供单测钉行为,生产唯一调用方是 handleDream。
- */
-export declare function runPostDreamMaintenance(host: DreamHandlerHost, memoryRoot: string): Promise<void>;
-export {};

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

@@ -1,66 +0,0 @@
-import type { GoalLoopCoordinator } from "../../orchestration/goal-loop-coordinator.js";
-import type { GoalInstructionKind, GoalTurnContext } from "../../orchestration/goal-run-types.js";
-export declare class GoalHandler {
-    private readonly coordinator;
-    private readonly activeDrivers;
-    constructor(coordinator: GoalLoopCoordinator);
-    private scheduleDrive;
-    start(params: {
-        goal: string;
-        cwd?: string;
-        agentPool?: string[];
-        budget?: {
-            maxTotalTokens?: number;
-            maxDurationMs?: number;
-        };
-        turnContext?: GoalTurnContext;
-    }): Promise<{
-        ok: true;
-        goalRunId: string;
-    }>;
-    message(params: {
-        goalRunId: string;
-        text: string;
-        kind?: GoalInstructionKind;
-    }): Promise<{
-        ok: true;
-        queued: true;
-    }>;
-    pause(params: {
-        goalRunId: string;
-    }): Promise<{
-        ok: true;
-    }>;
-    resume(params: {
-        goalRunId: string;
-        newGoal?: string;
-        additionalBudget?: {
-            maxTotalTokens?: number;
-            maxDurationMs?: number;
-        };
-    }): Promise<{
-        ok: true;
-    }>;
-    updateGoal(params: {
-        goalRunId: string;
-        newGoal: string;
-    }): Promise<{
-        ok: true;
-    }>;
-    stop(params: {
-        goalRunId: string;
-    }): Promise<{
-        ok: true;
-    }>;
-    recover(params: {
-        goalRunId: string;
-    }): Promise<{
-        ok: true;
-        recovered: boolean;
-    }>;
-    dismiss(params: {
-        goalRunId: string;
-    }): Promise<{
-        ok: true;
-    }>;
-}

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

@@ -1,23 +0,0 @@
-/** Agent-resident proposal extraction. Public search is Runtime Host-native. */
-import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
-import type { MemoryHandlerProvider } from "../../runtime/ports/index.js";
-import { type MemoryModelPurpose } from "../memory-candidate-service.js";
-interface MemoryLlmClient {
-    model: string;
-    apiKey: string;
-    transport: {
-        stream(request: Record<string, unknown>, apiKey: string): AsyncIterable<{
-            type: string;
-            text?: string;
-        }>;
-    };
-}
-export interface MemoryHandlerHost {
-    memoryProvider?: MemoryHandlerProvider | null;
-    memoryUserId?: string;
-    ensureMemoryProvider?(): void;
-    resolveClientForPurpose?(purpose: MemoryModelPurpose): MemoryLlmClient | null;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-}
-export declare function handleMemoryPropose(this: MemoryHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export {};

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

@@ -1,35 +0,0 @@
-/**
- * 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 } from "../../protocol/wire/index.js";
-import { type ProductCoordinatorHost } from "../product-coordinator.js";
-export type { ProductCoordinatorHost } from "../product-coordinator.js";
-export interface ProductHandlerHost extends ProductCoordinatorHost {
-    getActiveProjectRoot(): string;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-}
-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;
-/**
- * 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
- * `ProductPlanner.sessions` instead. Previously cancel only routed to `orchestrator.delete`, so
- * cancelling a stalled planning leader threw "Product not found" and never killed it.
- *
- * Strategy (idempotent):
- *  1. Try `orchestrator.delete` (post-confirm path).
- *  2. If that fails because the product isn't an orchestrator session ("not found"), fall back to
- *     `planner.cancel` (planning-phase path — kills the leader process).
- *  3. If neither side has the product, resolve ok rather than throwing (cancel is best-effort).
- */
-export declare function cancelProductAnyPhase(orchestrator: {
-    delete(productId: string, owner: ProductPlanningOwner): Promise<void>;
-}, planner: {
-    cancel(productId: string, owner: ProductPlanningOwner): Promise<void>;
-}, productId: string, owner: ProductPlanningOwner): Promise<void>;

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

@@ -1,29 +0,0 @@
-/**
- * Compute-only session handlers.
- *
- * Gateway owns project/session discovery, metadata, lifecycle and deletion. This
- * file deliberately retains only the three operations that require live agent
- * compute state: thread creation, history hydration for a supervised execution,
- * and a diagnostic snapshot of the current compute session.
- */
-import { createMemoryPrefetchState } from "../../runtime/hooks/memory-hooks.js";
-import { SessionState } from "../../runtime/session/session-state.js";
-import { type AgentRpcError, type AgentRpcErrorCode, type AgentRpcRequest } from "../../protocol/wire/index.js";
-import type { SessionHistoryCoordinator } from "../session-history-coordinator.js";
-export interface SessionHandlerHost {
-    currentSessionId?: string;
-    currentModel?: string;
-    sessionState?: SessionState | null;
-    memoryPrefetchState?: ReturnType<typeof createMemoryPrefetchState>;
-    sessionHistory: Pick<SessionHistoryCoordinator, "saveResumedSession">;
-    log(message: string): void;
-    setActiveWorkdir(workdir: string): void;
-    getActiveProjectRoot(): string;
-    enableIdleDream(): void;
-    sendNotification(method: string, params: Record<string, unknown>): void;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-    sendError(id: string | number, code: AgentRpcErrorCode | number, message: string, data?: unknown): void;
-}
-export declare function handleThreadCreate(this: SessionHandlerHost, msg: AgentRpcRequest): void;
-export declare function handleSessionResume(this: SessionHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleSessionGetInfo(this: SessionHandlerHost, msg: AgentRpcRequest): void;

package/dist/types/cli/handlers/skill-curator-handler.d.ts

@@ -1,8 +0,0 @@
-import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
-import type { HostCapabilityClient } from "../../transport/host-capability-client.js";
-export interface SkillCuratorHandlerHost {
-    getHostCapabilityClient(): HostCapabilityClient | undefined;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-}
-export declare function handleSkillsPromote(this: SkillCuratorHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleSkillsCurator(this: SkillCuratorHandlerHost, msg: AgentRpcRequest): Promise<void>;

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

@@ -1,25 +0,0 @@
-/**
- * Solo mode handlers — extracted from StdioServer.
- * Handles: solo.start, solo.cancel, solo.select,
- *          solo.delete, solo.message, solo.evaluate
- */
-import type { HostAgentProviderDirectory } from "../../runtime/infra/host-agent-provider-directory.js";
-import { SoloEvaluator } from "../../orchestration/solo-evaluator.js";
-import type { DelegateBridge } from "../../orchestration/delegate-bridge.js";
-import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
-export interface SoloHandlerHost {
-    soloEvaluator: SoloEvaluator | null;
-    providerDirectory: HostAgentProviderDirectory;
-    sendNotification(method: string, params: Record<string, unknown>): void;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-    handleMcpToolCall(memberId: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
-    /** Lazily resolves the required Gateway delegate rail. */
-    getDelegateBridge?(): DelegateBridge | undefined;
-}
-export declare function ensureSoloEvaluator(this: SoloHandlerHost): SoloEvaluator;
-export declare function handleSoloStart(this: SoloHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleSoloCancel(this: SoloHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleSoloSelect(this: SoloHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleSoloDelete(this: SoloHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleSoloMessage(this: SoloHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleSoloEvaluate(this: SoloHandlerHost, msg: AgentRpcRequest): Promise<void>;

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

@@ -1,8 +0,0 @@
-import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
-export interface TurnBaselineHandlerHost {
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-}
-export declare function handleTurnBaselineGetSummary(this: TurnBaselineHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleTurnBaselineListRecent(this: TurnBaselineHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleTurnBaselineGetFileBaseline(this: TurnBaselineHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleTurnBaselineGetFileDiff(this: TurnBaselineHandlerHost, msg: AgentRpcRequest): Promise<void>;

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

@@ -1,8 +0,0 @@
-import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-export interface WorkflowComputeHandlerHost {
-    toolCatalog?: ToolCatalog;
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-}
-/** Stateless compute port. Workflow definitions, runs, and approvals remain gateway-owned; authentication is outside Workflow. */
-export declare function handleComputeToolInvoke(this: WorkflowComputeHandlerHost, msg: AgentRpcRequest): Promise<void>;

package/dist/types/cli/handlers/working-materials-handler.d.ts

@@ -1,9 +0,0 @@
-import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
-export interface WorkingMaterialsHandlerHost {
-    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
-}
-export declare function handleWorkingMaterialsGet(this: WorkingMaterialsHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleWorkingMaterialsReplace(this: WorkingMaterialsHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleWorkingMaterialsUpsert(this: WorkingMaterialsHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleWorkingMaterialsRemove(this: WorkingMaterialsHandlerHost, msg: AgentRpcRequest): Promise<void>;
-export declare function handleWorkingMaterialsReorder(this: WorkingMaterialsHandlerHost, msg: AgentRpcRequest): Promise<void>;

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

@@ -1,57 +0,0 @@
-import { type DreamState } from "../agent/runtime-vars.js";
-import type { AgentRpcRequest } from "../protocol/wire/index.js";
-type TimerHandle = {
-    unref?: () => void;
-};
-export interface IdleDreamTimers {
-    setTimeout(callback: () => void, delayMs: number): TimerHandle;
-    clearTimeout(timerId: TimerHandle): void;
-}
-export interface IdleDreamClient {
-    model: string;
-    apiKey: string;
-}
-export interface IdleDreamCoordinatorOptions {
-    dreamState?: DreamState;
-    now?: () => number;
-    randomId?: () => string;
-    timers?: IdleDreamTimers;
-    log(message: string): void;
-    getCurrentSessionId(): string;
-    getCurrentTurnCount(): number;
-    hasForegroundTurn(): boolean;
-    resolveDreamClient(): IdleDreamClient | null;
-    resolveMemoryRoot(): string;
-    resolveTranscriptDir(): string;
-    listRecentSessions(): Promise<Array<{
-        sessionId: string;
-    }>>;
-    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?(signal: AbortSignal): Promise<void>;
-}
-export declare class IdleDreamCoordinator {
-    private readonly options;
-    private readonly dreamState;
-    private readonly now;
-    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, 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

@@ -1,26 +0,0 @@
-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

@@ -1,75 +0,0 @@
-interface MemoryLlmClient {
-    model: string;
-    apiKey: string;
-    transport: {
-        stream(request: Record<string, unknown>, apiKey: string): AsyncIterable<{
-            type: string;
-            text?: string;
-        }>;
-    };
-}
-/** Model purposes the memory pipeline can resolve (text + multimodal). */
-export type MemoryModelPurpose = "smallModel" | "textGeneration";
-export interface MemoryCandidateHost {
-    memoryProvider?: {
-        search?(query: string, userId: string, options?: {
-            limit?: number;
-        }): Promise<Array<{
-            id: string;
-            content: string;
-            score?: number;
-            metadata?: Record<string, unknown>;
-        }>>;
-    } | null;
-    resolveClientForPurpose?(purpose: MemoryModelPurpose): MemoryLlmClient | null;
-}
-export interface MemoryAttachment {
-    type: string;
-    filename: string;
-    mimeType: string;
-    text: string;
-    url: string;
-    path: string;
-    size?: number;
-}
-export interface RelatedMemoryHit {
-    id: string;
-    text: string;
-    score: number;
-    category?: string;
-}
-export interface MemoryCandidate {
-    id: string;
-    text: string;
-    category: string;
-    importance: number;
-    confidence: number;
-    source: string;
-    eventDate: string;
-    tags: string[];
-    relatedMemoryIds: string[];
-    evidence: Array<Record<string, unknown>>;
-    requiresConfirmation: boolean;
-    reason: string;
-}
-export interface MemoryCandidateParams {
-    text?: string;
-    attachments?: unknown[];
-    tags?: unknown;
-    category?: unknown;
-    importance?: unknown;
-    source?: unknown;
-    autoExtract?: boolean;
-}
-export declare function normalizeInputCandidate(input: unknown): MemoryCandidate | null;
-export declare function buildMemoryCandidates(ctx: MemoryCandidateHost, params: MemoryCandidateParams, userId: string): Promise<{
-    candidates: MemoryCandidate[];
-    related: RelatedMemoryHit[];
-    source: "llm" | "deterministic";
-}>;
-export declare function buildMemoryCandidateProposal(ctx: MemoryCandidateHost, params: MemoryCandidateParams, userId: string): Promise<{
-    candidates: MemoryCandidate[];
-    relatedMemories: RelatedMemoryHit[];
-    extractor: "llm" | "deterministic";
-}>;
-export {};