qlogicagent 2.12.8 → 2.12.10

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

@@ -9,90 +9,124 @@
  * The physical I/O layer is abstracted via the Transport interface.
  */
 import type { Transport } from "./transport.js";
-import { AcpServer } from "../transport/acp-server.js";
+import type { Agent } from "../agent/agent.js";
+import type { TurnConfig } from "../agent/types.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+import { type MemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
+import { SessionState } from "../runtime/session/session-state.js";
+import { TaskStore } from "../runtime/infra/task-runtime.js";
+import { BackgroundTaskManager } from "../runtime/infra/background-tasks.js";
+import { type TaskDomain } from "../runtime/prompt/task-domain.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 type { SessionLlmConfig } from "./acp-session-host.js";
+import { AgentRuntimeSessionState } from "./agent-runtime-session-state.js";
+import { type MultiAgentHandlerHost } from "./multi-agent-handler-host.js";
+import type { WorkflowHandlerHost } from "./handlers/workflow-handler.js";
+import { SessionHistoryCoordinator } from "./session-history-coordinator.js";
+import { PetConfirmCoordinator } from "./pet-confirm-coordinator.js";
+import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, ProjectMemoryStore } from "../runtime/ports/index.js";
 export interface StdioServerConfig {
     verbose: boolean;
     transport?: Transport;
 }
 export declare class StdioServer {
-    private running;
-    private readonly startedAt;
-    private readonly packageVersion;
-    private readonly rpcContract;
-    private readonly rpcIds;
-    private readonly rpcDeadlineTimers;
-    private activeTurn;
+    running: boolean;
+    readonly startedAt: number;
+    readonly packageVersion: string;
+    /** JSON-RPC request lifecycle: gateway contract, in-flight ledger, deadlines. */
+    private rpc;
+    /** Gateway contract — exposed for control-handler metrics/cancel. */
+    get rpcContract(): import("../protocol/wire/gateway-contract.js").GatewayRpcContract;
+    activeTurn: AbortController | null;
     /** Resolves when the active turn fully completes (including post-abort flush). */
     private turnDone;
-    private verbose;
+    verbose: boolean;
     private transport;
     private readonly runtimeServices;
     private readonly runtimeSession;
-    private agent;
-    private lastLlmConfigKey;
-    private currentSessionId;
-    private currentTurnId;
-    /** Cached LLM transport for sub-agent forks (dream) */
-    private currentTransport;
-    private currentApiKey;
-    private currentModel;
-    private currentProvider;
-    private currentBaseUrl;
-    /** Host-pinned per-session LLM config (session/set_config_option · set_model · /model). */
-    private sessionLlmConfig;
-    private sessionState;
+    /**
+     * DERIVED resolved-agent cache (Agent + LLM client snapshot). The invalidation
+     * invariant (full wipe on registry change vs forget-agent on session dispose)
+     * is localized in ResolvedAgentCache. Host-pinned sessionLlmConfig is separate
+     * and never touched by it.
+     */
+    private readonly resolvedAgent;
+    /** Active session/turn identity + lifecycle (id/turn/state/taskDomain/llmConfig/acpMeta). */
+    private readonly session;
     private currentMediaApiKeys;
-    private taskStore;
+    taskStore: TaskStore;
     /** Unified background execution registry (agent forks + backgrounded shell commands). */
-    private backgroundTasks;
+    backgroundTasks: BackgroundTaskManager;
     /** Settled-task notifications queued for injection into the next turn's context. */
     private pendingTaskNotifications;
     /** Session-scoped memory prefetch state (LRU dedup + byte limit). */
-    private memoryPrefetchState;
+    memoryPrefetchState: MemoryPrefetchState;
     /** Last user message text for auto-extract hook (set at turn start, cleared at turn end). */
     private lastUserMessageForAutoExtract;
     /** Last assistant message text for implicit extraction hook (set at turn end). */
     private lastAssistantMessageForExtract;
     /** MEMDIR file-based memory (CC memdir parity). */
-    private memdir;
-    private readonly projectMemoryStoreFactory;
+    memdir: ProjectMemoryStore | null;
+    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 */
-    private pendingAskUser;
-    /** Session-level task domain stickiness. Survives across turns within a session. */
-    private sessionTaskDomain;
-    /** ACP session-level context supplement (_meta from session/new), inherited by every prompt. */
-    private acpSessionMeta;
+    pendingAskUser: Map<string, {
+        resolve: (answers: Record<string, string> | null) => void;
+    }>;
     /** Agents/solo/product handler facade. */
-    private readonly multiAgentHandlerHost;
-    /** ACP Server instance — handles ACP protocol alongside legacy protocol. */
-    private acpServer;
-    private sessionHistory;
+    readonly multiAgentHandlerHost: MultiAgentHandlerHost;
+    /** Workflow handler host — carries toolCatalog + the lazy engine slots the multi-agent host lacks. */
+    readonly workflowHandlerHost: WorkflowHandlerHost;
+    /** ACP protocol coordinator — owns AcpServer lifecycle and ACP event mapping. */
+    private readonly acp;
+    sessionHistory: SessionHistoryCoordinator;
     private idleDreamCoordinator;
-    private readonly petConfirmCoordinator;
+    private readonly sessionRuntime;
+    readonly petConfirmCoordinator: PetConfirmCoordinator;
     private modelRegistryHydration;
     private get registry();
-    private get mediaClient();
-    private get mediaPersistence();
+    get mediaClient(): import("@xiaozhiclaw/provider-core/media-client").MediaClient;
+    get mediaPersistence(): import("../runtime/infra/media-persistence.js").MediaPersistence;
     private get pathService();
     get toolCatalog(): import("../runtime/ports/tool-contracts.js").ToolCatalog;
-    private get petRuntime();
-    private get currentHooks();
-    private get permissionChecker();
+    get petRuntime(): import("./pet-runtime.js").PetRuntime;
+    private get agent();
+    /** Cached LLM transport for sub-agent forks (dream). */
+    get currentTransport(): LLMTransport | null;
+    get currentApiKey(): string;
+    get currentModel(): string;
+    private get currentProvider();
+    private get currentBaseUrl();
+    get currentSessionId(): string;
+    set currentSessionId(v: string);
+    get currentTurnId(): string;
+    set currentTurnId(v: string);
+    get sessionState(): SessionState | null;
+    set sessionState(v: SessionState | null);
+    get sessionTaskDomain(): TaskDomain | undefined;
+    set sessionTaskDomain(v: TaskDomain | undefined);
+    get sessionLlmConfig(): SessionLlmConfig;
+    set sessionLlmConfig(v: SessionLlmConfig);
+    get acpSessionMeta(): Record<string, unknown> | null;
+    set acpSessionMeta(v: Record<string, unknown> | null);
+    get currentHooks(): import("../contracts/hooks.js").HookRegistry | null;
+    get permissionChecker(): AgentRuntimeSessionState["permissionChecker"];
     private set permissionChecker(value);
     private set mcpManager(value);
-    private get memoryProvider();
-    private set memoryProvider(value);
-    private get memoryDreamProvider();
-    private set memoryDreamProvider(value);
-    private get memoryUserId();
-    private set memoryUserId(value);
+    get memoryProvider(): MemoryHandlerProvider | null;
+    set memoryProvider(value: MemoryHandlerProvider | null);
+    get memoryDreamProvider(): MemoryDreamRuntimeProvider | null;
+    set memoryDreamProvider(value: MemoryDreamRuntimeProvider | null);
+    get memoryUserId(): string;
+    set memoryUserId(value: string);
     constructor(config: StdioServerConfig);
     /**
      * Get the active project workspace directory.
      * Reads from projectStore (single source of truth).
      */
-    private getActiveProjectRoot;
+    getActiveProjectRoot(): string;
     /**
      * Drain queued background-task completion notifications.
      * Called by the turn pipeline at turn start — settled tasks are injected
@@ -107,7 +141,7 @@ export declare class StdioServer {
      * Centralizes all side-effects (bootstrap workdir, media persistence, etc.).
      * Uses projectStore as the source of truth — no private field cache.
      */
-    private setActiveWorkdir;
+    setActiveWorkdir(dir: string): void;
     start(): void;
     stop(): Promise<void>;
     private readonly methodHandlers;
@@ -116,108 +150,30 @@ export declare class StdioServer {
      * Ensure a default project exists on first start.
      * Called from both legacy handleInitialize and ACP acpHandleInitialize.
      */
-    private ensureDefaultProject;
-    /**
-     * `thread.create` — create a new thread (session container).
-     * Maps threadId → sessionId for the underlying session system.
-     */
-    /**
-     * `thread.list` — list available threads. Delegates to session listing.
-     */
-    /**
-     * Resolve session for an inbound message.
-     * For desktop: chatId IS the sessionId — look it up directly.
-     * For group: look up by groupKey pattern.
-     * If not found, create a new session and return it.
-     */
+    ensureDefaultProject(): void;
     /**
      * Atomically resolve transport + model + apiKey for a given ModelPurpose.
      * If the resolved provider matches `this.currentProvider`, reuses cached transport.
      * Otherwise creates a one-shot client. Returns null if purpose is unresolvable.
      * This ensures side-ops always use fresh model from registry.
      */
-    private resolveClientForPurpose;
+    resolveClientForPurpose(purpose: import("../runtime/infra/model-registry.js").ModelPurpose): {
+        transport: LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
     /**
      * Ensure the L2 SQLite memory provider exists for read-only RPCs
      * (memory.atlas / memory.activity). These can be called before any turn has
      * run, so they cannot rely on resolveAgent() having initialized the provider.
      * Opening the DB is cheap and side-effect-free (list() does not embed).
      */
-    private ensureMemoryProvider;
-    private resolveAgent;
+    ensureMemoryProvider(): void;
+    resolveAgent(config: TurnConfig): Agent | null;
     private invalidateResolvedLlmCache;
-    /**
-     * Load LLM config from ModelRegistry (textGeneration binding).
-     * Returns provider/model/apiKey if found, undefined otherwise.
-     */
-    /**
-     * `session.getInfo` — Return session metadata, filesystem paths, and usage summary.
-     * Aligns with Codex/Copilot session introspection capability.
-     */
-    /**
-     * `memory.list` — Enumerate available memory sources (memdir + local sqlite).
-     */
-    /**
-     * `memory.read` — Read memory content from memdir (INDEX.md or topic file).
-     */
-    /**
-     * `memory.write` — Write memory content to memdir (INDEX.md or topic file).
-     */
-    /**
-     * `tools.list` — Return available tool definitions (local + MCP + plugin).
-     * Supports optional category filter.
-     */
-    /**
-     * `media.listModels` — List available media generation models.
-     * Desktop app uses this to populate the model selector per category.
-     */
-    /**
-     * `media.cancel` — Cancel an in-progress media generation task.
-     * Delegates to the provider's native cancellation API (e.g. Volcengine DELETE task).
-     */
-    /**
-     * `media.status` — Query the status of a media generation task.
-     * Returns provider-specific task status (e.g. queuing, running, succeeded, failed).
-     */
-    /** Resolve media API key for a provider from the current session config. */
-    /**
-     * `provider.list` — List all available LLM providers grouped by logical family.
-     * Returns protocol variants so callers can pick which transport to use.
-     */
-    /**
-     * `config.get` — Read current agent runtime configuration.
-     * Returns merged user-level + project-level settings.
-     */
-    /**
-     * `config.update` — Update agent runtime configuration (merges into settings.json).
-     */
-    /**
-     * `config.tunables` — Return all tunable default values with their current overrides.
-     */
-    /**
-     * `config.updateTunable` — Write a single tunable override into settings.json.tunables.
-     * Params: { key: string, value: number | boolean | string }
-     * Only keys that exist in TunableDefaults are accepted (validation).
-     */
-    /**
-     * `todos.list` — Query current todo items and summary.
-     * Invokes the registered todo tool's list action.
-     */
-    /**
-     * `memory.search` — Search memory via local SQLite provider or memdir keyword fallback.
-     */
-    /**
-     * `memory.delete` — Remove memory entry from memdir (INDEX.md line) or local store (by ID).
-     */
-    /**
-     * `tasks.list` — Query running/completed infrastructure tasks.
-     */
-    /**
-     * `tasks.cancel` — Cancel a running task by ID.
-     */
     /** Emit an `agents.status` notification when a child process state changes. */
     private emitAgentStatus;
-    private createDreamHandlerHost;
+    createDreamHandlerHost(): import("./handlers/dream-handler.js").DreamHandlerHost;
     private createAcpExtendedHandlerHost;
     /**
      * Handle an MCP tool call proxied from an external ACP agent via the
@@ -225,55 +181,22 @@ export declare class StdioServer {
      * system and returns the text result.
      */
     private handleMcpToolCall;
-    /** `agents.scan` — Scan for installed ACP agent CLIs. */
-    /** `agents.list` — Return cached agent descriptors. */
-    /** `agents.config` — Register / unregister / update custom agents. */
-    /** `agents.setConfig` — Set per-agent LLM / environment / model ID config. */
-    /** `agents.getConfig` — Get per-agent configuration. */
-    /** `agents.removeConfig` — Remove per-agent configuration. */
-    /** `agents.setGateway` — Set global gateway proxy URL. */
-    /** `solo.start` — Start a Solo Mode PK session. */
-    /** `solo.status` — Query solo session status. */
-    /** `solo.cancel` — Cancel a running solo session. */
-    /** `solo.select` — Select winner and merge worktree. */
-    /** Ensure ProductPlanner is initialized. */
-    /** `product.plan` — Start interactive planning with leader agent. */
-    /** `product.confirm` — User confirms the plan, transition to execution. */
-    /** `product.message` — User sends message to leader (multi-turn planning or execution intervention). */
-    /** `product.create` — Create a new Product Mode session. */
-    /** `product.resume` — Resume a paused product. */
-    /** `product.pause` — Pause a running product. */
-    /** `product.checkpoint` — Manual checkpoint. */
-    /** `product.status` — Query product status. */
-    /** `product.list` — List all products. */
-    /** `agents.getGateway` — Get the current global gateway proxy URL. */
-    /** `agents.listConfigured` — List agents that have persisted configuration. */
-    /** `agents.processes` — List all active child agent processes from solo/product PMs. */
-    /** `agents.kill` — Kill a child agent process by memberId. */
-    /** `agents.getLog` — Read stderr log for a specific agent. */
-    /** `agents.testConnection` — Spawn an agent with a short timeout to verify connectivity. */
-    /** `solo.list` — List all solo sessions. */
-    /** `solo.delete` — Delete a solo session and clean up resources. */
-    /** `solo.message` — Send follow-up message to a specific agent in solo session. */
-    /** `solo.evaluate` — User-triggered evaluation of solo session results. */
-    /** `product.delete` — Delete a product session and clean up resources. */
-    /** `product.cancel` — Cancel a running product. */
-    /** `product.rollback` — Rollback a product to a checkpoint. */
-    private sendResponse;
-    private sendContractError;
-    private sendContractErrorOrResult;
-    private scheduleRpcDeadline;
-    private clearRpcLifecycle;
-    private sendNotification;
+    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
+    /**
+     * Send a JSON-RPC error response by (code, message, data) — convenience over
+     * sendResponse for handlers that build the error inline (e.g. session.moveToProject
+     * error paths call `this.sendError`).
+     */
+    sendError(id: string | number, code: AgentRpcError["code"], message: string, data?: unknown): void;
+    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
     private writeStdout;
-    private log;
+    log(message: string): void;
     /**
      * Enable idle dream scheduling. Called after session setup when LLM config is available.
      */
     enableIdleDream(minutes?: number): void;
-    private cancelIdleDreamTimer;
+    cancelIdleDreamTimer(): void;
     disposeSessionRuntime(): void;
-    private closeMemoryProviders;
     /**
      * Initialize the ACP server alongside the legacy protocol.
      * Called once when the host is an ACP-compliant client.

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

@@ -0,0 +1,19 @@
+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;
+}
+export declare class StdioSessionRuntimeCoordinator {
+    private readonly deps;
+    constructor(deps: StdioSessionRuntimeCoordinatorDeps);
+    dispose(): void;
+    closeMemoryProviders(): void;
+}

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

@@ -0,0 +1,30 @@
+import type { PortableTool } from "../skills/portable-tool.js";
+import { type TaskToolHooks } from "../skills/tools/task-tool.js";
+import { type AskUserQuestion } from "../skills/tools/ask-user-tool.js";
+import { type ExecProgress } from "../skills/tools/exec-tool.js";
+import type { BackgroundTaskManager } from "../runtime/infra/background-tasks.js";
+import type { SandboxConfig } from "../skills/tools/shell/sandbox/sandbox-types.js";
+import { type PathService, type RuntimeToolContract } from "../runtime/ports/index.js";
+export interface LocalCoreToolRegistrationContext {
+    tools: PortableTool<any>[];
+    taskToolHooks?: TaskToolHooks;
+    backgroundTaskRuntime: BackgroundTaskManager | null;
+    askUserCallback: ((questions: AskUserQuestion[]) => Promise<Record<string, string> | null>) | null;
+    onExecProgress?: (progress: ExecProgress) => void;
+    getCwd(): string;
+    activeProjectRoot(): string;
+    resolveSandboxConfig(): SandboxConfig | undefined;
+    isGroupSecurityMode?(): boolean;
+    pathService?: PathService;
+    log?: {
+        info(message: string): void;
+        warn(message: string): void;
+    };
+    listToolNames(): string[];
+    findRegisteredTool(name: string): RuntimeToolContract | undefined;
+    activateRegisteredTool(name: string): boolean;
+}
+export declare function setGroupSecurityMode(enabled: boolean): void;
+export declare const localCoreToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<LocalCoreToolRegistrationContext>;
+export declare function registerLocalCoreTools(context: LocalCoreToolRegistrationContext): void;
+export declare function validateExecCommand(command: string, workdir: string, groupMode?: boolean): string | null;

package/dist/types/cli/tool-bootstrap-media-registration.d.ts

@@ -0,0 +1,8 @@
+import type { PortableTool } from "../skills/portable-tool.js";
+export interface LocalMediaToolRegistrationContext {
+    tools: PortableTool<any>[];
+    getCwd(): string;
+    activeProjectRoot(): string;
+}
+export declare const localMediaToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<LocalMediaToolRegistrationContext>;
+export declare function registerLocalMediaTools(context: LocalMediaToolRegistrationContext): void;

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

@@ -0,0 +1,7 @@
+export declare function resolveToolPath(input: string, cwd: string): string;
+/**
+ * Enforce absolute, mode-independent floors. Workspace membership belongs to
+ * the permission pipeline; this helper only blocks device/system paths that no
+ * permission mode should allow through local file/media tooling.
+ */
+export declare function enforceAbsoluteFloors(resolved: string): string | null;

package/dist/types/cli/tool-bootstrap-web-registration.d.ts

@@ -0,0 +1,13 @@
+import type { PortableTool } from "../skills/portable-tool.js";
+import type { ModelPurpose } from "../runtime/infra/model-registry.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+export interface LocalWebToolRegistrationContext {
+    tools: PortableTool<any>[];
+    resolveClientForPurpose?(purpose: ModelPurpose): {
+        transport: LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
+}
+export declare const localWebToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<LocalWebToolRegistrationContext>;
+export declare function registerLocalWebTools(context: LocalWebToolRegistrationContext): void;

package/dist/types/cli/tool-bootstrap-workflow-registration.d.ts

@@ -0,0 +1,7 @@
+import type { PortableTool } from "../skills/portable-tool.js";
+export interface LocalWorkflowToolRegistrationContext {
+    tools: PortableTool<any>[];
+    activeProjectRoot(): string;
+}
+export declare const localWorkflowToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<LocalWorkflowToolRegistrationContext>;
+export declare function registerLocalWorkflowTools(context: LocalWorkflowToolRegistrationContext): void;

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

@@ -1,16 +1,16 @@
 import type { PortableTool } from "../skills/portable-tool.js";
 import type { PermissionMode } from "../runtime/ports/permission-contracts.js";
-import { type TaskToolHooks } from "../skills/tools/task-tool.js";
-import { type ExecProgress } from "../skills/tools/exec-tool.js";
+import type { TaskToolHooks } from "../skills/tools/task-tool.js";
+import type { ExecProgress } from "../skills/tools/exec-tool.js";
 import type { BackgroundTaskManager } from "../runtime/infra/background-tasks.js";
 import type { ModelPurpose } from "../runtime/infra/model-registry.js";
 import type { LLMTransport } from "./provider-core-facade.js";
 import type { AgentLogger } from "../agent/types.js";
-import { type AskUserQuestion } from "../skills/tools/ask-user-tool.js";
+import type { AskUserQuestion } from "../skills/tools/ask-user-tool.js";
 import type { PathService, ToolCatalog } from "../runtime/ports/index.js";
 export { setMediaClientConfig, setProviderToolAPI } from "./media-runtime-facade.js";
-/** Enable or disable group security mode (blocks sensitive file access). */
-export declare function setGroupSecurityMode(enabled: boolean): void;
+export { setGroupSecurityMode, validateExecCommand } from "./tool-bootstrap-core-registration.js";
+export { enforceAbsoluteFloors } from "./tool-bootstrap-paths.js";
 export interface SandboxPermissionSnapshot {
     mode: PermissionMode;
     workdir: string;
@@ -20,12 +20,6 @@ export interface SandboxPermissionSnapshot {
 }
 /** Wire the OS-sandbox permission source (live rule-engine snapshot), or null to clear. */
 export declare function setSandboxPermissionSource(source: (() => SandboxPermissionSnapshot | undefined) | null): void;
-/** Set callback invoked after LLM-driven project switch. */
-export declare function setProjectSwitchCallback(cb: ((project: {
-    id: string;
-    name: string;
-    workspaceDir: string;
-}) => void) | undefined): void;
 /**
  * Set task tool lifecycle hooks. Called from stdio-server when session starts.
  * Connects planning-task events to the HookRegistry.
@@ -44,17 +38,6 @@ export declare function setBackgroundTaskRuntime(manager: BackgroundTaskManager
  */
 export declare function setAskUserCallback(callback: ((questions: AskUserQuestion[]) => Promise<Record<string, string> | null>) | null): void;
 export declare function setBootstrapWorkdir(newWorkdir: string): void;
-/**
- * Enforce absolute, mode-independent floors. Returns an error message only for
- * dangers that are NEVER allowed regardless of permission mode, null otherwise.
- *
- * Workspace membership is NO LONGER decided here: cross-workspace access is owned
- * by the permission pipeline (the `tool.before_invoke` hook), which prompts in
- * `default` mode and allows in `auto`/`full_access`. This function only blocks
- * device/system paths that no mode should ever touch via file tools.
- */
-export declare function enforceAbsoluteFloors(resolved: string): string | null;
-export declare function validateExecCommand(command: string, _workdir: string): string | null;
 export interface BootstrapConfig {
     workdir?: string;
     toolCatalog?: ToolCatalog;

package/dist/types/cli/tunable-store.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Tunable override store — the SINGLE write/read path for settings.tunables.
+ *
+ * Shared by the config.updateTunable RPC (UI settings page) and the `config`
+ * tool (conversational tuning), so both go through identical validation,
+ * persistence, and runtime sync. Values are hot: ModelRegistry.getTunable()
+ * re-reads settings.json on every call, so a persisted override takes effect
+ * on the next read with no restart.
+ */
+import { type TunableDefaults } from "../runtime/config/tunable-defaults.js";
+/** Read the current override map from settings.json (missing file → empty). */
+export declare function readTunableOverrides(settingsPath: string): Record<string, unknown>;
+/**
+ * Validate a tunable update against the declared defaults.
+ * Returns an error message, or null when the update is acceptable.
+ * Coercible values ("3" → 3, "true" → true) are NOT accepted here —
+ * callers wanting leniency must coerce before validating.
+ */
+export declare function validateTunableUpdate(key: string, value: unknown): string | null;
+/** Coerce a string value toward the tunable's declared type ("3"→3, "true"→true). */
+export declare function coerceTunableValue(key: string, value: unknown): unknown;
+/** Persist one override into settings.json and sync live runtime state. */
+export declare function writeTunableOverride(settingsPath: string, key: string, value: unknown): Promise<void>;
+/** Remove one override (value falls back to the declared default). */
+export declare function clearTunableOverride(settingsPath: string, key: string): Promise<void>;
+export type { TunableDefaults };

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

@@ -0,0 +1,29 @@
+import type { AgentRpcError } from "../protocol/wire/index.js";
+import type { MultiAgentHandlerHost } from "./multi-agent-handler-host.js";
+import type { WorkflowHandlerHost } from "./handlers/workflow-handler.js";
+/**
+ * WorkflowHostAdapter — the host the legacy `workflow.*` JSON-RPC domain binds to.
+ *
+ * The workflow handlers (workflow.create/run/list/onImMessage/onWebhook/…) need MORE than the
+ * agents/solo/product sub-host provides: `toolCatalog` (workflow `tool` nodes look up real
+ * qlogicagent tools via `findTool`) plus the lazy engine slots that `ensureWorkflowController`
+ * fills (controller/store/scheduler/processManager). The multi-agent sub-host has neither, so
+ * binding workflow there left `this.toolCatalog` undefined — a workflow `tool` node would throw
+ * "Cannot read properties of undefined (reading 'findTool')" at run time. This adapter supplies
+ * the missing pieces explicitly, mirroring createDreamHostAdapter / createAcpExtendedHostAdapter.
+ *
+ * `acpDetector` is sourced from the multi-agent sub-host so workflow `agent` nodes resolve the same
+ * canonical external descriptors that the `agents.*` domain configures. The engine slots are plain
+ * own-properties this (per-agent singleton) adapter owns and `ensureWorkflowController` mutates once;
+ * keeping them here means the controller it publishes via setWorkflowController stays a singleton and
+ * the multi-agent sub-host is no longer polluted with workflow state.
+ */
+export interface WorkflowHostAdapterDeps {
+    multiAgentHost: MultiAgentHandlerHost;
+    getActiveProjectRoot(): string;
+    getToolCatalog(): WorkflowHandlerHost["toolCatalog"];
+    handleMcpToolCall: WorkflowHandlerHost["handleMcpToolCall"];
+    sendNotification(method: string, params: Record<string, unknown>): void;
+    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
+}
+export declare function createWorkflowHostAdapter(deps: WorkflowHostAdapterDeps): WorkflowHandlerHost;

package/dist/types/contracts/hooks.d.ts

@@ -170,6 +170,12 @@ export interface HookRegistration<P extends HookPoint = HookPoint> {
     priority?: number;
     /** Optional label for debugging */
     label?: string;
+    /**
+     * Critical hooks are part of the execution preflight. If they throw, the
+     * registry returns an abort result instead of treating the failure as a
+     * non-blocking observer error.
+     */
+    critical?: boolean;
 }
 /**
  * Interface for a hook registry that manages hook handlers.

package/dist/types/orchestration/workflow/run-history-store.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Run History Store — durable per-workflow run records (闭环 "察" 半场).
+ *
+ * The checkpoint store (run-checkpoint-store.ts) is an execution cache that is
+ * DELETED when a run completes — it cannot answer "what did the last run do?".
+ * This store keeps a bounded, append-style history per workflow so the canvas
+ * can show past runs and per-node outputs:
+ *
+ *   `<project>/.qlogicagent/workflows/<workflowId>/runs/history.json`
+ *
+ * Recording happens in WorkflowController.run() — the single choke point every
+ * trigger path goes through (manual RPC, cron scheduler, IM, webhook) — so
+ * scheduled runs are captured identically to manual ones.
+ *
+ * Node outputs are stored as TRUNCATED JSON previews (default-port items'
+ * `json`), not full PortMaps: history is for inspection, the checkpoint cache
+ * remains the execution-fidelity layer. Bounded to the most recent
+ * MAX_RUN_HISTORY entries; corrupt/missing history degrades to empty (history
+ * must never block a run).
+ */
+import type { RunResult } from "./workflow-runtime.js";
+export declare const MAX_RUN_HISTORY = 20;
+export type RunHistoryStatus = "running" | "completed" | "failed" | "paused" | "skipped";
+export interface RunNodeRecord {
+    /** Whether the node's executor actually ran (false = checkpoint cache hit). */
+    executed: boolean;
+    /** Truncated JSON preview of the node's output items (port → items[].json). */
+    preview: string;
+}
+export interface RunHistoryEntry {
+    runId: string;
+    status: RunHistoryStatus;
+    triggerType: string;
+    startedAt: string;
+    finishedAt?: string;
+    durationMs?: number;
+    error?: string;
+    /** nodeId → output record. Present once the run settles (not while running). */
+    nodes?: Record<string, RunNodeRecord>;
+}
+/** Summary row for list views — full node outputs stay behind get(). */
+export type RunHistorySummary = Omit<RunHistoryEntry, "nodes">;
+/** Build per-node output previews from a settled RunResult. */
+export declare function buildNodeRecords(result: RunResult): Record<string, RunNodeRecord>;
+export declare class WorkflowRunHistoryStore {
+    private readonly cwd;
+    constructor(cwd: string);
+    /** Record a run start. Prepends a "running" entry and prunes to the bound. */
+    begin(workflowId: string, entry: Pick<RunHistoryEntry, "runId" | "triggerType" | "startedAt">): Promise<void>;
+    /** Settle a run entry (status/outputs/error). Unknown runId is a no-op (pruned entry). */
+    finish(workflowId: string, runId: string, patch: Partial<Pick<RunHistoryEntry, "status" | "finishedAt" | "durationMs" | "error" | "nodes">>): Promise<void>;
+    /** Most-recent-first run summaries (no node outputs — those stay behind get()). */
+    list(workflowId: string): Promise<RunHistorySummary[]>;
+    /** Full entry incl. per-node output previews. */
+    get(workflowId: string, runId: string): Promise<RunHistoryEntry | undefined>;
+    private read;
+    private write;
+}