qlogicagent 2.18.12 → 2.19.2

package/dist/types/runtime/infra/acp-detector.d.ts

@@ -1,271 +0,0 @@
-/**
- * ACP Agent Detector — scans PATH for installed ACP-compatible CLI agents.
- *
- * Uses `which` (Unix) / `where` (Windows) to locate CLI binaries,
- * then optionally probes version. Results are cached with TTL.
- *
- * Reference: AionUI AcpDetector + ACP_BACKENDS_ALL registry.
- */
-import type { AcpBackendConfig, AgentDescriptor, CustomAgentDef, AgentConfigStoreData, AuthPreference } from "../../protocol/wire/acp-agent-management.js";
-export declare const ACP_BACKENDS: Record<string, AcpBackendConfig>;
-export declare const AGENT_CATALOG_IDS: readonly ["claude", "codex", "gemini", "copilot", "cursor", "qwen", "kimi", "glm", "opencode", "kiro", "qoder", "openclaw", "hermes"];
-/** Merged catalog entry (base ACP config + grid/install metadata) for one id. */
-export declare function getCatalogEntry(id: string): AcpBackendConfig | undefined;
-/** Ordered curated catalog: base ACP config merged with grid/install metadata. */
-export declare function getAgentCatalog(): AcpBackendConfig[];
-export declare function buildInternalAgentDescriptors(): AgentDescriptor[];
-export declare function resolveWindowsCopilotLoader(): string | null;
-export declare function getNpmInstallPackageName(command: string | undefined): string | null;
-export declare function compareSemverVersions(a: string, b: string): number;
-export declare function isVersionNewer(latest: string | null | undefined, current: string | null | undefined): boolean;
-export declare function readGlobalNpmPackageVersion(packageName: string | null | undefined): string | null;
-export declare function resolveInstalledNpmPackageVersionFromInstall(install: AcpBackendConfig["install"] | undefined): string | null;
-export declare function getCatalogInstalledVersion(entry: AcpBackendConfig, detectedVersion?: string): string | undefined;
-/** Resolve a package's latest published version via `npm view` (async + cached). Used by the background
- *  update check so N agents resolve concurrently (one `npm view` each) instead of blocking sequentially. */
-export declare function fetchNpmLatestPackageVersionAsync(packageName: string | null | undefined, registry?: string): Promise<string | null>;
-export interface CatalogUpdateInfo {
-    id: string;
-    packageName?: string;
-    installedVersion?: string;
-    latestVersion?: string;
-    updateAvailable: boolean;
-}
-/**
- * Resolve latest-version / update-available info for the catalog's INSTALLED agents, all in PARALLEL
- * (one concurrent `npm view` per package). Non-installed agents are skipped (nothing to update).
- * Returns only entries where a latest version was resolved. Safe to call off the catalog hot path.
- */
-export declare function getCatalogUpdateInfoAsync(entries: ReadonlyArray<{
-    id: string;
-    entry: AcpBackendConfig;
-    detectedVersion?: string;
-}>, registry?: string): Promise<CatalogUpdateInfo[]>;
-/**
- * Synchronous, NETWORK-FREE update info read straight from the persisted cache (disk-seeded on first
- * use). Returns immediately so the panel lights up last-known badges INSTANTLY — VS Code's gallery
- * pattern — without waiting on `npm view`. `stale` is true when any installed package's cached "latest"
- * is missing, errored, or older than the TTL; the caller then refreshes via getCatalogUpdateInfoAsync
- * in the background, and the next call serves the fresh value.
- */
-export declare function getCatalogUpdateInfoCached(entries: ReadonlyArray<{
-    id: string;
-    entry: AcpBackendConfig;
-    detectedVersion?: string;
-}>, registry?: string): {
-    updates: CatalogUpdateInfo[];
-    stale: boolean;
-};
-export declare function normalizeWindowsAcpCommand(cliPath: string, args: string[]): {
-    cliPath: string;
-    acpArgs: string[];
-};
-/**
- * Build the spawn env for an external ACP backend.
- *
- * Maps the agent-config's portable `apiKey`/`baseUrl` onto the backend-declared
- * environment-variable names (`apiKeyEnvVar`/`baseUrlEnvVar`) so a user who only
- * configures an API key + base URL (e.g. via agents.setConfig) actually drives the
- * underlying CLI with a third-party OpenAI/Anthropic-compatible gateway — no official
- * account login required. Without this mapping the backends declared the env-var names
- * but nothing ever populated them.
- *
- * Precedence (lowest → highest), so explicit user input always wins:
- *   1. backend.env            (static backend defaults)
- *   2. mapped apiKey/baseUrl  (config.apiKey → backend.apiKeyEnvVar, etc.)
- *   3. customConfig.env       (raw env the user hand-entered)
- *
- * Injection is conditional: the apiKey/baseUrl mapping only fires when the backend
- * actually declares the corresponding envVar name (so we never invent a var the CLI
- * does not read). Returns undefined when there is nothing to inject, preserving the
- * prior `env?: undefined` behavior for un-configured backends.
- */
-export declare function buildBackendEnv(backend: AcpBackendConfig | undefined, customConfig: import("../../protocol/wire/acp-agent-management.js").AgentConfig | undefined, autoEnv?: Record<string, string>): Record<string, string> | undefined;
-/** Unified key sources for login-free catalog injection (wired by the runtime). */
-export interface CatalogKeySources {
-    /** Gateway-issued inference key (sk-qllm) for keySource:"llmrouter". */
-    llmrouterKey?: string;
-    /** Base URL an llmrouter-routed agent should call (our gateway endpoint). */
-    llmrouterBaseUrl?: string;
-    /** Resolve an agent/protocol-specific LLMRouter base URL. */
-    getLlmrouterBaseUrl?: (agentId: string, entry: AcpBackendConfig) => string | null | undefined;
-    /** Default LLMRouter model for agent CLIs that require an explicit model pin. */
-    llmrouterModel?: string;
-    /** Resolve a provider's direct third-party key for keySource:"direct". */
-    getDirectKey?: (providerId: string) => string | null | undefined;
-    /** The host's active text-generation model (deepseek / volcengine / …) to "pass through" to
-     *  OpenAI-compatible spawned agents (codex/qwen/opencode) that resolve no key of their own — so
-     *  they run on the configured key+baseUrl+model with zero per-agent credentials. */
-    passthroughModel?: {
-        apiKey: string;
-        baseUrl?: string;
-        model?: string;
-    };
-    /** Probe: does this agent have a usable native account/subscription login (e.g. ~/.codex/auth.json,
-     *  present + not expired)? Drives `account`-mode readiness and `auto`'s account-first preference.
-     *  Tri-state: true = detected login, false = probeable but not logged in (blocks readiness), undefined
-     *  = no probe for this agent (treated as ready-if-installed; auto does NOT pick account). Wired in Cut 4. */
-    hasSubscription?: (agentId: string) => boolean | undefined;
-}
-/** Resolve the effective mode, coercing unsupported combinations (claude.account → auto). */
-export declare function effectiveAuthPreference(entry: AcpBackendConfig, mode: AuthPreference): AuthPreference;
-/**
- * The credential-source modes the UI should offer for an agent (derived from catalog metadata, the
- * single source of truth — spec §4.2/§8.2/§15). Never includes a permanently-dead option:
- *   - oauth / keyless (copilot/cursor/kimi/…): ["account"] only (no gateway endpoint to repoint)
- *   - claude (Anthropic bans subscription): ["managed","userKey"] — no account
- *   - codex (llmrouter + account-capable): ["account","userKey","managed"]
- *   - other llmrouter agents: ["userKey","managed"]
- *   - direct agents (qwen/glm/…): ["userKey"] (managed wiring for qwen/opencode is Cut 7)
- */
-export declare function getAvailableAuthModes(entry: AcpBackendConfig): AuthPreference[];
-/**
- * Resolve the login-free key env for a catalog agent, honoring the per-agent `authPreference`.
- *   - "account" → {} (inject nothing; the spawn layer also deletes the forwarded key, see resolveSuppressEnvKeys)
- *   - "userKey" → the user's own provider key against the official endpoint (no gateway baseUrl/model)
- *   - "managed" → force the gateway sk-qllm + baseUrl (ignores any user key) — guarantees a first conversation
- *   - "auto"    → ladder: user's own key (if present) → managed gateway → host-model passthrough
- * oauth / keyless agents never get a key injected. Only emits env vars the backend declares.
- */
-export declare function resolveCatalogKeyEnv(entry: AcpBackendConfig | undefined, sources: CatalogKeySources, mode?: AuthPreference): Record<string, string>;
-/**
- * Env var names the spawn layer must DELETE from the merged child env (account mode), so a
- * forwarded/stale shell key cannot override the CLI's own native login. This is the load-bearing
- * half of the §1.3 override-bug fix: buildBackendEnv alone cannot unset a whitelist-forwarded key.
- * Returns [] when not in account mode (or the agent has no account path — claude is coerced to auto).
- */
-export declare function resolveSuppressEnvKeys(entry: AcpBackendConfig | undefined, mode: AuthPreference, sources?: CatalogKeySources): string[];
-/**
- * Build a backend's descriptor from already-resolved cliPath/version (+ the caller-resolved
- * hasConfig flag). Shared by AcpDetector's sync and async detection paths so they can never drift
- * (status rules, copilot's version-required gate, etc.) — extracted to a standalone, IO-free, pure
- * function (not a class method) so it is directly unit-testable without spawning a real CLI.
- *
- * sessionHistory (Task 1.2, third-party native session discovery): "native-cwd" only for an
- * INSTALLED (status "available") codex or claude backend — the two agents whose native CWD-scoped
- * session stores we've actually adapted to. Every other case — not-installed codex/claude, any other
- * backend regardless of install state — falls back to "own". Unadapted agents ALWAYS get "own"; this
- * is a hard invariant, not a default that later widens implicitly.
- */
-export declare function assembleBackendDescriptor(backend: AcpBackendConfig, cliPath: string | null, version: string | null, hasConfig: boolean): AgentDescriptor;
-/** Build a user-registered custom agent's descriptor. Extracted to a standalone, IO-free, pure
- *  function for the same testability reason as {@link assembleBackendDescriptor}. Custom agents are
- *  never adapted for native session discovery — regardless of what id/name the user gives them —
- *  so sessionHistory is always "own" (the hard own-by-default invariant). */
-export declare function assembleCustomAgentDescriptor(custom: CustomAgentDef, cliPath: string | null, hasConfig: boolean): AgentDescriptor;
-export declare class AcpDetector {
-    private cache;
-    /** Last scan that COMPLETED, surviving clearCache() and failed rescans. list() prefers this
-     *  over an empty [] so a transient probe failure never reads as "no agents installed". */
-    private lastGoodScan;
-    private configStore;
-    private keySources;
-    /** Shared in-flight async scan so concurrent scanAsync() callers (startup warm + a racing RPC)
-     *  collapse onto ONE scan instead of each spawning its own probe storm. Cleared when it settles. */
-    private scanInFlight;
-    /**
-     * Provide the config store data so detector can populate `hasConfig` field
-     * and include user-registered custom agents.
-     */
-    setConfigStore(data: AgentConfigStoreData): void;
-    /** Wire the unified key sources for login-free catalog injection. */
-    setKeySources(sources: CatalogKeySources): void;
-    /**
-     * Scan for installed ACP agent CLIs.
-     * @param force - Clear cache and re-scan.
-     */
-    scan(force?: boolean): AgentDescriptor[];
-    /**
-     * Async, NON-BLOCKING twin of {@link scan}. Probes every backend CONCURRENTLY off the event loop
-     * (async `where`/`which` + version probes), so the engine's single-threaded loop keeps servicing
-     * ACP requests while detection runs — fixing the bug where a cold synchronous scan (11–18s here,
-     * 60s+ with more/slower CLIs) starved an already-dispatched `x/product.confirm` until it tripped
-     * the UI's 60s timeout. Populates the SAME cache as scan(), so a later sync list()/scan(false)
-     * returns instantly. Concurrent callers share one in-flight scan ({@link scanInFlight}).
-     *
-     * @param force - Bypass the fresh-cache short-circuit and re-probe.
-     */
-    scanAsync(force?: boolean): Promise<AgentDescriptor[]>;
-    private runScanAsync;
-    /**
-     * Return cached results without IO. 冷缓存时后台预热（scanAsync）并返回 []，
-     * 绝不在 RPC 路径上同步 scan —— 同步探测（11-18s+）会饿死单线程引擎循环
-     * （x/product.confirm 60s 超时的根因）。调用方按"稍后再查"处理空列表。
-     *
-     * A background-scan failure is reported (console.error), never swallowed: a swallowed
-     * failure made list() return [] forever and downstream (product planning) treated
-     * "scan failed" as "no agents installed". When the fresh cache is gone but an older
-     * scan succeeded, that stale-but-real result is returned instead of [].
-     */
-    list(): AgentDescriptor[];
-    /** Clear the detection cache. */
-    clearCache(): void;
-    private detectBackend;
-    /** Async, NON-BLOCKING twin of {@link detectBackend} — identical detection, async probes. */
-    private detectBackendAsync;
-    private detectCustomAgent;
-    /** Async, NON-BLOCKING twin of {@link detectCustomAgent}. */
-    private detectCustomAgentAsync;
-    private hasAgentConfig;
-    /**
-     * Descriptor for qlogicagent participating in Solo/Product as a self-hosted ACP agent.
-     *
-     * qlogicagent's own CLI speaks ACP by default (cli/main.ts: ACP server unless --no-acp), so a
-     * participant is just another `node <cli.js>` process. The child reads the SAME owner-profile
-     * settings.json (model-registry), so it runs with the configured provider (deepseek / volcengine /
-     * llmrouter) — that is how the configured model "passes through" to every qlogicagent instance,
-     * with no per-agent key. We forward the owner-profile + llmrouter env so the child resolves its
-     * model identically to this (host) process. This lets Solo run N independent qlogicagent sessions
-     * in parallel (each its own worktree) — the core "多个 qlogicagent = 多会话并行" use case.
-     */
-    private buildSelfDescriptor;
-    /**
-     * Build an ExternalAgentDescriptor suitable for Gateway Supervisor resolution.
-     * Returns null if the agent is not available.
-     */
-    buildExternalDescriptor(agentId: string): import("../../protocol/wire/acp-agent-management.js").ExternalAgentDescriptor | null;
-    /**
-     * Async, NON-BLOCKING twin of {@link buildExternalDescriptor} — identical output for the same
-     * detector state, but resolves the agent list via {@link scanAsync} (a real probe, awaited, when
-     * the cache is cold) instead of the sync {@link list}'s cache-or-empty shortcut. Load-bearing for
-     * `agents.warm` (agents-handler.ts): the sync path's detect calls are cache-fronted today, but
-     * that non-blocking guarantee is an implementation detail of `list()` — routing the RPC path
-     * through this method instead makes "never synchronously probe on this path" an explicit
-     * contract that can't silently regress if `list()`'s internals change later.
-     */
-    buildExternalDescriptorAsync(agentId: string): Promise<import("../../protocol/wire/acp-agent-management.js").ExternalAgentDescriptor | null>;
-    /** Shared descriptor-assembly logic for {@link buildExternalDescriptor} and
-     *  {@link buildExternalDescriptorAsync} — everything AFTER "locate this agentId's AgentDescriptor
-     *  in an already-resolved list", so the sync/async twins can never drift on behavior, only on how
-     *  they obtain `agents`. */
-    private assembleExternalDescriptorFromAgents;
-    /**
-     * Whether an agent is ready to compete in Solo/Product: installed/available AND configured.
-     * qlogicagent self-resolves from the owner profile (always ready). External agents need a usable
-     * ACP descriptor (installed) and, for key-auth backends, the key env resolved (configured by the
-     * user on the welcome page). Used by the 启动 pre-check so a race never starts with an agent that
-     * would fail its turn ("No LLM provider"/auth). Does NOT verify the key is *valid* — that's only
-     * known at runtime.
-     */
-    /**
-     * Tri-state native-login state for the credential UI's account label — distinct from isAgentReady.
-     * `true` = a native login/subscription was actually detected (e.g. codex ~/.codex/auth.json); `false`
-     * = probeable but not logged in; `undefined` = no probe for this agent (e.g. hermes' own `acp --setup`
-     * store, which we can't read). isAgentReady treats undefined as ready-if-installed so the CLI gets a
-     * chance to run, but the UI must NOT claim "已登录" on undefined — it just doesn't know.
-     */
-    getNativeLoginState(agentId: string): boolean | undefined;
-    isAgentReady(agentId: string): boolean;
-    /**
-     * Fast-fail guard for the turn path: returns a user-facing error when an agent is in a key-required
-     * credential mode (managed / userKey / auto-resolving-to-key) but NO usable key got injected — so the
-     * caller can reject the turn cleanly instead of spawning a CLI that would silently stall on auth (the
-     * host then goes quiet → the gateway's hang-watchdog kills it → the user sees a cryptic "Agent process
-     * stdio closed"). Returns null when credentialed, or when the mode owns its own native login
-     * (account / oauth / keyless), or when we can't be sure a key is needed.
-     */
-    resolveCredentialError(agentId: string): string | null;
-}
-/** Best-effort resolve the backing model id for an agent (for the planning roster).
- *  Returns the configured/auto model or undefined. No spawn — reads config + auto env only. */
-export declare function resolveAgentModel(detector: AcpDetector, id: string): string | undefined;

package/dist/types/runtime/infra/agent-config-store.d.ts

@@ -1,30 +0,0 @@
-/**
- * Agent Config Store — persistent per-agent configuration with project + global fallback.
- *
- * Storage paths:
- *   - Project-level: `<cwd>/.qlogicagent/agent-configs.json`
- *   - User-level:    `~/.qlogicagent/profiles/<owner>/agent-configs.json`
- *
- * Merge strategy: project-level overrides take precedence.
- * Sensitive fields (apiKey) use file permissions 0o600 on Unix.
- */
-import type { AgentConfig, AgentConfigStoreData, CustomAgentDef } from "../../protocol/wire/acp-agent-management.js";
-export declare class AgentConfigStore {
-    private data;
-    private cwd;
-    constructor(cwd?: string);
-    /** Load config from disk. Project-level merges on top of user-level. */
-    load(): Promise<void>;
-    /** Get the full store data (for AcpDetector.setConfigStore). */
-    getData(): AgentConfigStoreData;
-    getAgentConfig(agentId: string): AgentConfig | null;
-    setAgentConfig(agentId: string, config: AgentConfig): Promise<void>;
-    removeAgentConfig(agentId: string): Promise<void>;
-    getGatewayUrl(): string | undefined;
-    setGatewayUrl(url: string): Promise<void>;
-    registerCustomAgent(def: CustomAgentDef): Promise<void>;
-    unregisterCustomAgent(agentId: string): Promise<void>;
-    getCustomAgents(): Record<string, CustomAgentDef>;
-    /** Save to user-level config. Restricts permissions for sensitive data. */
-    private save;
-}

package/dist/types/runtime/infra/agent-install-runner.d.ts

@@ -1,80 +0,0 @@
-import type { AgentInstallSpec } from "../../protocol/wire/acp-agent-management.js";
-export type InstallEvent = {
-    type: "state";
-    state: "installing" | "verifying" | "installed" | "failed";
-} | {
-    type: "log";
-    stream: "stdout" | "stderr";
-    chunk: string;
-} | {
-    type: "done";
-    ok: boolean;
-    error?: string;
-};
-/** A child process shaped like node's, so tests can inject a fake. */
-export interface InstallProc {
-    stdout?: {
-        on(ev: "data", cb: (c: Buffer | string) => void): void;
-    } | null;
-    stderr?: {
-        on(ev: "data", cb: (c: Buffer | string) => void): void;
-    } | null;
-    on(ev: "close", cb: (code: number | null) => void): void;
-    on(ev: "error", cb: (err: Error) => void): void;
-}
-export type InstallSpawn = (command: string, shell: boolean) => InstallProc;
-/**
- * Choose the best official install command for the current platform.
- * Preference: brew (macOS only) → npm → pip → curl (POSIX shell only). Returns the raw
- * command + whether it must run through a shell (curl pipelines / shell metachars).
- */
-export declare function pickInstallCommand(install: AgentInstallSpec, platform: NodeJS.Platform): {
-    command: string;
-    shell: boolean;
-} | null;
-/**
- * Inject a package-registry mirror into an install command, for users behind slow or blocked public
- * registries (e.g. PyPI / npm from mainland China, where the default index frequently times out).
- *
- * Opt-in via `mirror`: "cn" applies curated China mirrors per package manager; off (undefined) by
- * default so other users are unaffected. Only rewrites a command that hasn't already pinned a
- * registry/index, and never touches brew/curl. Returns the command unchanged when not applicable.
- */
-export declare function applyInstallMirror(command: string, mirror: string | undefined): string;
-/** Default spawner: split into argv (or run via shell for pipelines). */
-export declare const defaultInstallSpawn: InstallSpawn;
-/**
- * Run an install spec end-to-end, streaming progress via onEvent. Emits state →
- * log(s) → (verify) → done. Resolves with the final outcome.
- */
-export declare function runAgentInstall(install: AgentInstallSpec, onEvent: (e: InstallEvent) => void, opts?: {
-    platform?: NodeJS.Platform;
-    spawnImpl?: InstallSpawn;
-    mirror?: string;
-}): Promise<{
-    ok: boolean;
-    error?: string;
-}>;
-/**
- * Open an OS terminal window running an agent's interactive login/setup command (e.g. `kimi login`,
- * `hermes acp --setup`). The local desktop host can spawn a real terminal so the user completes the
- * CLI's own login flow without leaving the app. Detached + unref so it outlives the engine. The command
- * is a fixed catalog string (no user input) → no injection surface.
- */
-export declare function launchSetupTerminal(command: string, platform?: NodeJS.Platform): {
-    ok: boolean;
-    error?: string;
-};
-/**
- * Fire-and-forget install in a FULLY DETACHED process (own session/process-group, no stdio shared with
- * us). Used for self/host-platform agents (xiaozhiclaw) whose in-place UPDATE would otherwise disrupt the
- * running engine the install is a child of — "Agent process stdio closed". Returns immediately; the new
- * version is live on the agent's next startup. No progress streaming (the process is detached).
- */
-export declare function runAgentInstallDetached(install: AgentInstallSpec, opts?: {
-    platform?: NodeJS.Platform;
-    mirror?: string;
-}): {
-    ok: boolean;
-    error?: string;
-};

package/dist/types/runtime/infra/external-agent-approvals.d.ts

@@ -1,59 +0,0 @@
-/**
- * Pending interactive-approval registry for EXTERNAL agents.
- *
- * When a spawned external agent (Codex/Claude/…) asks for permission (ACP session/request_permission),
- * the host handler forwards the request to the frontend and parks the ACP response here until the user
- * decides. The gateway delivers the decision via the agents.approvalResponse RPC, which resolves the
- * matching pending promise so the host handler can return the chosen optionId to the external agent.
- *
- * This is the qlogicagent-side mirror of the gateway adapter's pendingPermissionRequests map.
- */
-/**
- * Park an approval until the user decides. Resolves with the chosen optionId, or null on timeout
- * (the caller then applies a safe default). Idempotent per approvalId — a duplicate replaces the old.
- */
-export declare function awaitApprovalDecision(approvalId: string, timeoutMs: number): Promise<string | null>;
-/** Deliver the user's decision. Returns false if no approval was pending for this id (no-op). */
-export declare function resolveApprovalDecision(approvalId: string, optionId: string): boolean;
-/** Cancel all pending approvals (e.g. on shutdown) — resolves them as null so awaiters unblock. */
-export declare function cancelAllApprovals(): void;
-export declare function pendingApprovalCount(): number;
-export interface ApprovalForwardDeps {
-    agentId: string;
-    /** Current streaming turn identity (read fresh each call, since members are reused across turns). */
-    turnContext: () => {
-        sessionId?: string;
-        turnId?: string;
-        requestId?: string;
-    } | null;
-    /** Emit the forward notification to the gateway (→ turn.approval_request → UI card). */
-    sendNotification?: (method: string, params: Record<string, unknown>) => void;
-    timeoutMs?: number;
-}
-/**
- * 激活层(S3c §1.1)delegate 路径的审批决议:输入是 SupervisorEventSink.onApprovalRequest 的已翻译
- * 形状(toolName/options 已扁平,非 ACP 原始 session/request_permission params)。决议序与旧路径
- * forwardExternalApproval 逐条对齐:①AstraClaw 只读能力自批 ②有交互上下文 → forward()发 UI 卡 +
- * 同一 PENDING registry 等 agents.approvalResponse ③无上下文/超时 → reject 回退。返回最终 optionId
- * (不透明,E2);调用方拿它走 x/delegate.respond(gateway 唯一应答口 respondApproval)。
- */
-export declare function decideExternalApproval(input: {
-    agentId: string;
-    approvalId: string;
-    toolName?: string;
-    options: Array<Record<string, unknown>>;
-    /** 有流式回合上下文(turnId 在)才值得转 UI 卡;否则直接回退 reject。 */
-    hasInteractiveContext: boolean;
-    /** 发 agents.prompt.approval UI 卡(形状归属调用方;只在需要用户决议时调用)。 */
-    forward: () => void;
-    timeoutMs?: number;
-}): Promise<string>;
-/**
- * Drive one interactive approval for an external agent: forward the ACP session/request_permission
- * to the user (agents.prompt.approval), await the decision, and return the chosen optionId. Falls
- * back to a reject option if there's no streaming turn context or the user doesn't decide in time.
- * Pure + injectable so the bidirectional loop is unit-testable without a live agent.
- */
-export declare function forwardExternalApproval(params: Record<string, unknown>, deps: ApprovalForwardDeps): Promise<{
-    optionId: string;
-}>;

package/dist/types/runtime/infra/migrate-device-scope.d.ts

@@ -1,49 +0,0 @@
-/**
- * One-shot migration: fold legacy PER-PROFILE install assets into the device-level store.
- *
- * 设计裁定:安装的插件/技能/MCP 是【设备资产】,跟随机器;只有会话/记忆/设置/偏好随登录身份
- * (owner profile)。历史版本把 skills/plugins/mcp.json/skill-lifecycle.json 挂在
- * profiles/<owner>/ 下,登录切身份 → 引擎换 profile → 已装插件"消失"、预装跨身份失效。
- *
- * 折并规则(活跃 owner 的 profile 先处理,它的副本优先):
- *   - skills/<name>:  设备层缺 → 整目录 rename 进设备 store;同名且 SKILL.md 内容一致 → 丢弃
- *     profile 副本;同名不同内容 → 原地保留 + 大声告警(绝不静默覆盖)。
- *   - plugins/<name>: 设备层缺 → rename;同名 → 原地保留 + 告警(插件目录内容不可比对)。
- *   - skill-lifecycle.json: 按技能名合并进设备层 store(先到优先),消费掉的文件改名
- *     `*.migrated-to-device` 留痕。
- *   - mcp.json: 服务器按名合并(先到优先、绝不覆盖已有键),消费掉的文件同样改名留痕。
- *   - marketplace.json: 设备层缺 → rename 采用;已有 → 原地保留 + 告警。
- *   - skills-disabled.json(全局静音表): 与技能 store 同为设备资产 —— 各 profile 取【并集】合入
- *     设备层(保守方向:任何身份下停放/静音过的技能绝不因迁移静默点亮;agent 自建技能的
- *     "默认停放"正是靠这张表,漏并会让它们在别的身份下全部亮起)。消费掉的文件改名留痕。
- *   - plugin-cache/、cache/community-installs/: 纯下载缓存,直接删除。
- *
- * 会话伴生数据(第二批裁定,对齐 codex/VS Code —— 会话也随设备):
- *   - projectData/<pid>/: 设备层缺该 pid → 整目录 rename;同 pid 跨 profile(同一 workspace 在
- *     多身份下用过,path-derived id 相同)→ 结构化合并:sessions/、checkpoints/、uploads/ 的
- *     子项按【uuid 名】跳已存在(同名=同一会话的陈旧副本,活跃身份先到先得);sessions/.deleted
- *     墓碑按文件名并集;project.json back-ref 先到先得(输家副本可安全删除,注册表每次写都会重生成)。
- *     未能并尽的残留原地保留 + 计入 conflicts(绝不静默销毁)。
- *   - projects.json(注册表): 按项目 id 合并(先到先得);activeProjectId 继承第一个有效值
- *     (活跃身份优先)。折并须在 rebuildIndexFromBackrefs 之前跑 —— 否则自愈会先用空注册表
- *     重建、丢掉 active 指针等索引态。
- *
- * 幂等:按目录状态驱动(profile 里没有遗留 → 全程 no-op),每次启动同步段调用都安全。
- */
-export interface DeviceScopeMigrationResult {
-    movedSkills: string[];
-    movedPlugins: string[];
-    /** projectData/<pid> trees moved or merged into the device store. */
-    movedProjects: string[];
-    /** Same-name different-content entries left in place (loud warning emitted). */
-    conflicts: string[];
-    /** Profile files (lifecycle/mcp/marketplace/registry/mute) whose content was folded into the device store. */
-    mergedFiles: string[];
-}
-/**
- * Fold every profile's legacy install assets into the device-level store. Bounded (rename-based),
- * idempotent, best-effort with loud per-item diagnostics. Call from the SYNCHRONOUS bootstrap
- * section BEFORE anything reads the skill store — on an upgraded machine every installed skill
- * still lives under profiles/ until this runs.
- */
-export declare function migrateDeviceScopeInstalls(): DeviceScopeMigrationResult;

package/dist/types/runtime/infra/project-data-gc.d.ts

@@ -1,15 +0,0 @@
-/**
- * Project Data GC — best-effort startup reclamation of the companion-data tree, mirroring VS Code's
- * UnusedWorkspaceStorageDataCleaner. A projectData/<id> dir is KEPT when it's either in projects.json
- * OR carries a `project.json` back-ref (the durable truth — rebuildIndexFromBackrefs runs first and
- * re-indexes it). Only a dir with NEITHER (truly corrupt/orphaned — crashed mid-create) is reclaimed.
- * This makes the registry non-load-bearing for recovery: a lost projects.json never causes data loss.
- * Also prunes stale deletion tombstones. NEVER touches live projects' data or the user's workspace.
- *
- * TRULY ASYNC (not just deferred): the iteration count grows with every project dir ever created on
- * this machine (unbounded on a long-lived box). Following the AcpDetector.scanAsync convention, this
- * uses fs/promises and awaits between each directory — every await yields the event loop, so an RPC
- * that arrives mid-GC is dispatched between directories instead of waiting for the whole sweep. The
- * keep/reclaim judgment is unchanged; only the sync fs calls became awaited yield points.
- */
-export declare function gcOrphanProjectData(): Promise<void>;

package/dist/types/runtime/session/native/claude-session-source.d.ts

@@ -1,23 +0,0 @@
-import type { NativeSessionEntry, NativeSessionRef, NativeSessionSource, TranscriptMessage } from "./native-session-source.js";
-/**
- * Native session source for Claude Code (claude CLI). Reads directly from
- * `~/.claude/projects/<claudeProjectDirName(cwd)>/<sessionUuid>.jsonl` — the same on-disk format
- * Claude Code itself writes, so this is read-only and never touched by qlogicagent.
- *
- * `isSidechain: true` events are subagent side-chains, not part of the user-visible conversation,
- * and are filtered out of both list() (message counting / title / lastActiveAt) and
- * loadTranscript() (transcript body).
- */
-export declare class ClaudeSessionSource implements NativeSessionSource {
-    private readonly home;
-    readonly agentId = "claude";
-    readonly kind: "claude";
-    /** `home` is injectable so tests can point at a temp directory instead of the real user home. */
-    constructor(home?: string);
-    list(cwd: string, opts?: {
-        limit?: number;
-    }): Promise<NativeSessionEntry[]>;
-    /** A claude native session is exactly the file `<encoded-cwd>/<sessionUuid>.jsonl` — a single stat. */
-    has(sessionId: string, cwd: string): Promise<boolean>;
-    loadTranscript(ref: NativeSessionRef): Promise<TranscriptMessage[]>;
-}

package/dist/types/runtime/session/native/codex-index.d.ts

@@ -1,21 +0,0 @@
-import type { NativeSessionEntry } from "./native-session-source.js";
-/**
- * Lists codex-native sessions belonging to `normalizedTargetCwd` (already run through
- * {@link normalizeCwd} by the caller), sorted by `lastActiveAt` descending.
- *
- * Synchronous by design — built entirely on sync fs calls, since it's a Cut 3 building block; a
- * future CodexSessionSource adapter (mirroring claude-session-source.ts's shape) would wrap this in
- * the async `NativeSessionSource.list()` contract.
- *
- * `messageCount` is always 0: unlike claude's one-line-per-message transcript format, a codex
- * rollout interleaves many event types per turn, so computing an exact count means fully parsing
- * every candidate rollout's entire event stream — deliberately out of scope here. Revisit if/when a
- * caller actually needs an exact count.
- *
- * Never throws: a missing/unreadable codexHome, sessions dir, session_index.jsonl, or cache file all
- * degrade to "as if empty" rather than propagating an error.
- */
-export declare function listCodexSessionsByCwd(normalizedTargetCwd: string, opts?: {
-    codexHome?: string;
-    cacheDir?: string;
-}): NativeSessionEntry[];

package/dist/types/runtime/session/native/codex-session-source.d.ts

@@ -1,31 +0,0 @@
-import type { NativeSessionEntry, NativeSessionRef, NativeSessionSource, TranscriptMessage } from "./native-session-source.js";
-/**
- * Native session source for Codex (codex CLI / codex_cli_rs) — Cut 3 Task 3.2.
- *
- * `list()` delegates entirely to {@link listCodexSessionsByCwd} (Task 3.1), which already handles
- * cwd filtering, title/lastActiveAt joining against session_index.jsonl, and mtime-keyed caching;
- * this adapter only adds the async `NativeSessionSource.list()` contract and cwd normalization on
- * top of that synchronous building block (mirroring ClaudeSessionSource's shape).
- *
- * `loadTranscript()` reads a single rollout file and keeps only `event_msg` lines whose payload is
- * `user_message` or `agent_message` with `phase: "final_answer"` — see {@link CodexEventMsgLine}'s
- * doc for why every other line/event/payload type in a rollout is intentionally skipped.
- */
-export declare class CodexSessionSource implements NativeSessionSource {
-    private readonly opts;
-    readonly agentId = "codex";
-    readonly kind: "codex";
-    /** `opts` is injectable (codexHome/cacheDir) so tests can point at temp directories instead of
-     *  the real user home — mirrors listCodexSessionsByCwd's own opts shape. */
-    constructor(opts?: {
-        codexHome?: string;
-        cacheDir?: string;
-    });
-    list(cwd: string, opts?: {
-        limit?: number;
-    }): Promise<NativeSessionEntry[]>;
-    /** Codex has no id->file mapping without the index (id lives in each rollout's session_meta), so
-     *  membership goes through the mtime-cached listCodexSessionsByCwd (no full re-scan when warm). */
-    has(sessionId: string, cwd: string): Promise<boolean>;
-    loadTranscript(ref: NativeSessionRef): Promise<TranscriptMessage[]>;
-}

package/dist/types/runtime/session/native/cwd-normalize.d.ts

@@ -1,53 +0,0 @@
-/**
- * Normalize a cwd for CODEX session-cwd equality comparisons (matching a codex rollout's
- * `session_meta.cwd` against our own workspace cwd). Same rule in spirit as projectId derivation
- * (see agent-paths.ts `deriveProjectId`: resolve + lowercase) — resolve to an absolute path, then
- * lowercase and force forward-slash separators so both `E:\Foo\Bar` and `e:/foo/bar` compare equal.
- * (path.resolve() already normalizes `/` to `\` on win32, so the explicit slash replace below is
- * belt-and-suspenders rather than load-bearing — verified via `path.resolve("e:/xiaozhiclaw/openclaw")`
- * === `"e:\\xiaozhiclaw\\openclaw"` on this machine — but kept explicit so the output format doesn't
- * silently depend on that internal, unstated Node behavior.)
- */
-export declare function normalizeCwd(cwd: string): string;
-/**
- * Encode a cwd into the directory name Claude Code uses under `~/.claude/projects/<encoded>`.
- *
- * This is Claude Code's OWN encoding (not ours) — we must replicate it byte-for-byte to locate
- * existing native claude session directories on disk. It has no public spec, so this was reverse
- * engineered two ways and cross-checked against each other:
- *
- *   1. Real directory names from `ls ~/.claude/projects` on this dev machine (see
- *      cwd-normalize.test.ts for the samples, notably a workspace with a literal space in its name
- *      — "QA Agent Mention Pool 20260701-1325" — which is what falsified the initially-assumed
- *      narrower rule).
- *   2. Decompiling the bundled VS Code extension (anthropic.claude-code-2.1.168,
- *      extension/extension.js). The relevant minified functions (renamed here for readability;
- *      originals were Hv/yv/pOe/cOe):
- *
- *        const MAX_LEN = 200;
- *        function hashCode(e) {                               // Java String.hashCode()-style,
- *          let t = 0;                                          // 32-bit signed, wraps via `|0`
- *          for (let r = 0; r < e.length; r++) t = (t << 5) - t + e.charCodeAt(r) | 0;
- *          return t;
- *        }
- *        function encodeProjectDirName(e) {
- *          const t = e.replace(/[^a-zA-Z0-9]/g, "-");
- *          if (t.length <= MAX_LEN) return t;
- *          return `${t.slice(0, MAX_LEN)}-${Math.abs(hashCode(e)).toString(36)}`;
- *        }
- *
- * Two things this rule does that a naive "just swap \\/:. for -" guess would get wrong:
- *   - The replacement set is "everything that isn't [a-zA-Z0-9]", not a fixed 4-character set —
- *     spaces, underscores, parens, plus signs, and non-ASCII (e.g. Chinese) characters are all
- *     replaced too. Original casing is preserved (no lowercasing, unlike normalizeCwd above).
- *   - Encoded names longer than 200 characters are truncated to 200 chars plus a
- *     "-<base36 32-bit hash>" suffix, where the hash is computed over the ORIGINAL
- *     (pre-replacement) string, not the truncated one.
- *
- * This encoding is lossy/one-way by construction (e.g. `...\\qlogicagent-hub` and
- * `...\\qlogicagent\\hub` both encode to the same name) — it can only be used to look up a
- * directory for a known cwd, never to recover a cwd from a directory name. If Claude Code changes
- * this encoding in a future version, update this function and the fixtures in
- * cwd-normalize.test.ts together.
- */
-export declare function claudeProjectDirName(cwd: string): string;