qlogicagent 2.15.6 → 2.15.8

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

@@ -22,6 +22,12 @@ export declare function handleSkillsActivate(this: SkillsHandlerHost, msg: Agent
 export declare function handleSkillsDeactivate(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
 export declare function handleSkillsDelete(this: SkillsHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleSkillsPromote(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
+/**
+ * Per-project opt-out: mute (or un-mute) a globally-installed skill in ONE project so the agent
+ * doesn't see it there — cuts context and mis-triggering without uninstalling the skill. The file
+ * stays in the global store and stays active in every other project. This is the "本项目技能" toggle.
+ */
+export declare function handleSkillsSetProjectDisabled(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
 export declare function handleSkillsStats(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
 export declare function handleSkillsPin(this: SkillsHandlerHost, msg: AgentRpcRequest): void;
 export declare function handleSkillsUnpin(this: SkillsHandlerHost, msg: AgentRpcRequest): void;

package/dist/types/cli/skills-query-service.d.ts

@@ -2,10 +2,12 @@ export interface SkillListEntry {
     id: string;
     name: string;
     path: string;
-    /** Effective in this project: globally-scoped, or enabled via the project manifest. */
+    /** Effective in this project: not globally muted and not muted in this project. */
     active: boolean;
-    /** Enablement scope (= lifecycle enabledScope). "global" is active everywhere. */
-    scope: "project" | "global";
+    /** Muted everywhere (the plugin card's off switch). */
+    globallyDisabled: boolean;
+    /** Muted in THIS project only (the project opt-out). */
+    projectDisabled: boolean;
     category: "automation";
     displayName: {
         key: string;

package/dist/types/cli/test-support/fs-cleanup.d.ts

@@ -0,0 +1,19 @@
+export interface RmWithRetryOptions {
+    /** Retries after the first attempt before giving up. Default 5. */
+    retries?: number;
+    /** Base backoff in ms; doubles each retry (100, 200, 400, …). Default 100. */
+    baseDelayMs?: number;
+    /** Removal primitive — injectable so the retry/backoff logic is unit-testable. */
+    remove?: (target: string) => void;
+}
+/**
+ * Recursively remove a path, retrying with exponential backoff when Windows
+ * reports a transient file lock.
+ *
+ * Cleanup is best-effort: a leaked directory under the OS temp dir is harmless
+ * and the OS reaps it, so exhausting the retries warns (loud and visible) instead
+ * of throwing — a teardown race must never fail a test that already verified the
+ * behaviour under test. A *non-transient* error (e.g. a bad path) is a real bug
+ * and is rethrown immediately.
+ */
+export declare function rmWithRetry(target: string, options?: RmWithRetryOptions): Promise<void>;

package/dist/types/protocol/wire/acp-agent-management.d.ts

@@ -5,7 +5,7 @@
  * external ACP-compatible agent CLIs alongside qlogicagent's internal agents.
  */
 import type { AgentCapabilities, CustomAgentDef, AgentConfig, ProductTaskStatus, ProductInstanceDef, ProductTaskDef } from "./agent-methods.js";
-export type { AgentCategory, AgentProtocol, AgentStatus, AgentCapabilities, AgentDescriptor, CustomAgentDef, AgentConfig, SoloState, SoloAgentState, SoloAgentResult, SoloStatus, ProductPhase, ProductTaskStatus, ProductInstanceDef, ProductTaskDef, ProductStatus, ProductSummary, } from "./agent-methods.js";
+export type { AgentCategory, AgentProtocol, AgentStatus, AgentCapabilities, AgentDescriptor, CustomAgentDef, AgentConfig, AuthPreference, SoloState, SoloAgentState, SoloAgentResult, SoloStatus, ProductPhase, ProductTaskStatus, ProductInstanceDef, ProductTaskDef, ProductStatus, ProductSummary, } from "./agent-methods.js";
 /** Pre-defined configuration for a known ACP backend. */
 export interface AcpBackendConfig {
     /** Backend ID, e.g. "claude" | "codex" | "goose". */
@@ -71,6 +71,13 @@ export interface ExternalAgentDescriptor {
     acpArgs: string[];
     /** Extra environment variables for spawn. */
     env?: Record<string, string>;
+    /**
+     * Env var names the spawn layer must DELETE from the merged child env (after Object.assign of `env`),
+     * so a forwarded/stale shell key cannot override the CLI's own native login. Set in `account` mode
+     * (the load-bearing fix for the env-injection-override bug — buildBackendEnv alone cannot unset a
+     * whitelisted forwarded key). See acp-detector.resolveSuppressEnvKeys.
+     */
+    suppressEnvKeys?: string[];
     /** Communication protocol. */
     protocol: "acp";
 }

package/dist/types/protocol/wire/agent-methods.d.ts

@@ -46,6 +46,15 @@ export interface CustomAgentDef {
     skillsDirs?: string[];
     supportsBaseUrlOverride?: boolean;
 }
+/**
+ * Per-agent credential source preference (BYO-account/key axis).
+ *  - "auto"    : ladder — detected native account → user's own key → managed gateway (default; reproduces legacy behavior).
+ *  - "managed" : force the platform gateway (sk-qllm); guarantees a first conversation, ignores any user key.
+ *  - "account" : use the CLI's own native account/subscription login; inject NO key (the spawn layer also deletes any
+ *                forwarded key) so the CLI's own credential store wins. Not available for claude (Anthropic bans 3rd-party OAuth).
+ *  - "userKey" : use the user's own provider API key against the official endpoint (no gateway baseUrl override).
+ */
+export type AuthPreference = "auto" | "managed" | "account" | "userKey";
 /** Persisted per-agent configuration. */
 export interface AgentConfig {
     apiKey?: string;
@@ -55,6 +64,8 @@ export interface AgentConfig {
     customArgs?: string[];
     customCliPath?: string;
     modelIdMap?: Record<string, string>;
+    /** Credential-source preference (undefined ⇒ "auto"; see AuthPreference). No migration needed. */
+    authPreference?: AuthPreference;
 }
 export type SoloState = "running" | "evaluating" | "completed" | "cancelled" | "failed";
 export type SoloAgentState = "pending" | "running" | "completed" | "failed" | "idle";
@@ -1620,26 +1631,35 @@ export interface AgentRpcMethodMap extends GatewayRpcMethodMap {
     "skills.delete": {
         params: {
             name: string;
-            scope?: "project" | "global";
         };
         result: {
             ok: true;
             deleted: string;
-            scope: string;
             signalStatus?: string;
         };
     };
     "skills.promote": {
         params: {
             name: string;
-            keepLocal?: boolean;
         };
         result: {
             ok: true;
             promoted: string;
             scope: "global";
             globalPath: string;
-            removedFromProject: boolean;
+        };
+    };
+    "skills.setProjectDisabled": {
+        params: {
+            name: string;
+            disabled: boolean;
+            projectId?: string;
+        };
+        result: {
+            ok: true;
+            name: string;
+            disabled: boolean;
+            changed: boolean;
         };
     };
     "skills.stats": {

package/dist/types/protocol/wire/gateway-rpc.d.ts

@@ -438,7 +438,10 @@ export interface GatewayRpcMethodMap {
                 name: string;
                 path: string;
                 active: boolean;
-                scope: "project" | "global";
+                /** Muted everywhere (the plugin card's off switch). */
+                globallyDisabled: boolean;
+                /** Muted in THIS project only (the per-project opt-out). */
+                projectDisabled: boolean;
                 category: CapabilityCategoryWire;
                 displayName: LocalizedTextWire;
                 displayDescription: LocalizedTextWire;
@@ -446,6 +449,7 @@ export interface GatewayRpcMethodMap {
                 fallbackDescription: string;
                 systemGenerated: boolean;
                 version?: string;
+                registryVersion?: string;
                 description?: string;
             }>;
         };
@@ -639,6 +643,16 @@ export interface AgentCallOptions {
     idempotencyKey?: string;
     traceId?: string;
 }
-export type AgentCall = <M extends keyof GatewayRpcMethodMap>(method: M, params: GatewayRpcMethodMap[M]["params"], options?: AgentCallOptions) => Promise<GatewayRpcMethodMap[M]["result"]>;
+/**
+ * Gateway → agent RPC. The gateway is a GENERIC proxy: alongside the strongly-typed methods in
+ * GatewayRpcMethodMap (first call signature — params/result inferred), it must forward arbitrary
+ * methods by name — dynamic dispatch, and methods not (yet) in the map — via the second signature
+ * (opaque params/result). The typed signature is listed first so known method literals resolve to
+ * it; a plain `string` method falls through to the proxy signature.
+ */
+export type AgentCall = {
+    <M extends keyof GatewayRpcMethodMap>(method: M, params: GatewayRpcMethodMap[M]["params"], options?: AgentCallOptions): Promise<GatewayRpcMethodMap[M]["result"]>;
+    (method: string, params?: Record<string, unknown>, options?: AgentCallOptions): Promise<unknown>;
+};
 /** All gateway-facing RPC method names (runtime array). */
 export declare const GATEWAY_RPC_METHODS: (keyof GatewayRpcMethodMap)[];

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

@@ -6,7 +6,7 @@
  *
  * Reference: AionUI AcpDetector + ACP_BACKENDS_ALL registry.
  */
-import type { AcpBackendConfig, AgentDescriptor, AgentConfigStoreData } from "../../protocol/wire/acp-agent-management.js";
+import type { AcpBackendConfig, AgentDescriptor, 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. */
@@ -85,16 +85,40 @@ export interface CatalogKeySources {
         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;
 /**
- * Resolve the login-free key env for a catalog agent from the unified key sources.
- * "set key once in our system → all agents" — the user never logs into each CLI.
- *   - authMode "oauth" / keySource "none" → {} (no bypass; account required)
- *   - keySource "llmrouter" → gateway sk-qllm + gateway baseUrl (agent calls our gateway)
- *   - keySource "direct"    → the user's provider key (agent calls the provider directly)
- * Only emits env vars the backend actually declares (apiKeyEnvVar / baseUrlEnvVar).
+ * 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 resolveCatalogKeyEnv(entry: AcpBackendConfig | undefined, sources: CatalogKeySources): Record<string, string>;
+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[];
 export declare class AcpDetector {
     private cache;
     private configStore;

package/dist/types/runtime/infra/acp-protocol-adapter.d.ts

@@ -62,7 +62,30 @@ export interface AcpAuthMethod {
     id?: string;
     name?: string;
     description?: string;
+    /**
+     * ACP auth-method discriminator (when the agent follows the discriminated schema):
+     *  - "agent"    : the agent self-drives login (opens its own browser / prints a device code)
+     *  - "env_var"  : the user supplies a key — surface a key dialog (≈ userKey)
+     *  - "terminal" : run an interactive login command (the agent's own `login` subcommand)
+     * Drives how the host routes the login affordance (see classifyAuthMethod). Absent on agents that
+     * don't tag their methods — those fall back to guide-only.
+     */
+    type?: "agent" | "env_var" | "terminal" | string;
+    /** For a terminal-type method: the command + args the host runs to start the interactive login. */
+    args?: string[];
+    /** For a terminal-type method: extra env for the login command. */
+    env?: Record<string, string>;
 }
+/** How the host should surface a login for an advertised auth method (spec §7). */
+export type AuthMethodRouting = "agent" | "key" | "terminal" | "guide";
+/**
+ * Route an advertised auth method to the right login affordance:
+ *  agent → drive the ACP `authenticate` request; env_var → open a key dialog (userKey); terminal →
+ *  run the agent's interactive login command; otherwise guide-only (show the command, user runs it).
+ * Gating login on a concrete classified method (never a heuristic) prevents firing an uncompletable
+ * login (e.g. claude's key-only method) — spec §7 risk.
+ */
+export declare function classifyAuthMethod(method: AcpAuthMethod | undefined): AuthMethodRouting;
 /**
  * Thrown when an agent rejects session setup because the user must authenticate first — e.g. kimi
  * returns -32000 "Authentication required" with a `kimi login` authMethod. Carries the agent's

package/dist/types/runtime/infra/agent-paths.d.ts

@@ -66,8 +66,8 @@ export declare function getProjectAgentDir(cwd: string): string;
 export declare function getProjectWorkflowsDir(cwd: string): string;
 /** `<cwd>/.qlogicagent/plugins/` */
 export declare function getProjectPluginsDir(cwd: string): string;
-/** `<cwd>/.qlogicagent/skills-enabled.json` — per-project skill enablement manifest. */
-export declare function getProjectSkillManifestPath(cwd: string): string;
+/** `<cwd>/.qlogicagent/skills-disabled.json` — per-project skill opt-out (mute) list. */
+export declare function getProjectSkillDisabledPath(cwd: string): string;
 /** `<cwd>/.qlogicagent/settings.json` */
 export declare function getProjectSettingsPath(cwd: string): string;
 /** `<cwd>/.qlogicagent/INSTRUCTIONS.md` */

package/dist/types/runtime/infra/agent-process.d.ts

@@ -141,6 +141,17 @@ export interface AgentProcessCallbacks {
     sessionDir?: string;
 }
 export declare function ensureLoopbackNoProxy(env: Record<string, string>): Record<string, string>;
+/**
+ * Merge an external descriptor's env onto the forwarded base env, then DELETE any `suppressEnvKeys`
+ * (account mode). This is the load-bearing half of the env-injection-override fix: `Object.assign` can
+ * only add/overwrite, so a whitelist-forwarded `ANTHROPIC_API_KEY`/`OPENAI_API_KEY` (from the gateway's
+ * own shell) would otherwise survive into the child and override the CLI's native subscription login.
+ * Deleting after the merge guarantees `account` mode hands credential control to the CLI's own store.
+ */
+export declare function applyExternalDescriptorEnv(env: Record<string, string>, ext: {
+    env?: Record<string, string>;
+    suppressEnvKeys?: string[];
+}): Record<string, string>;
 /**
  * Build LLM-related environment variables for an external ACP teammate.
  *

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

@@ -30,6 +30,13 @@ export interface PooledAgentEntry {
         current: PooledTurnCtx | null;
     };
     lastUsed: number;
+    /**
+     * Set when a credential-mode change (authPreference / key / login) arrived while this process was
+     * mid-turn. The env is baked at spawn, so the switch can only take effect by respawning — but we must
+     * not abort the in-flight turn (D2: "下条消息生效"). The turn-runner evicts the entry once the turn
+     * settles (settlePooledTurn), so the NEXT turn respawns with the new credentials.
+     */
+    pendingRecredential?: boolean;
 }
 /** Pool key: same agent + workspace + session ⇒ same resident process (and shared memory). */
 export declare function poolKey(agentId: string, cwd: string, sessionId?: string): string;
@@ -47,6 +54,22 @@ export declare function adoptWarmedAgent(warmKey: string, sessionKey: string): P
 export declare const WARM_SESSION = "__warm__";
 /** Drop + dispose a single entry (e.g. after a turn errors and the process is suspect). */
 export declare function evictPooledAgent(key: string): void;
+/**
+ * Invalidate every resident process for an agent after a credential-mode change (authPreference / key /
+ * login). The spawn env is baked at spawn time and reused across turns, so a switch only takes effect by
+ * respawning. Idle/warm entries are evicted immediately; a busy entry (turn in flight) is flagged
+ * `pendingRecredential` and evicted by settlePooledTurn when its turn settles (D2: never abort the
+ * in-flight turn — the switch lands on the next message). Returns counts for UI messaging.
+ */
+export declare function evictPooledAgentsByAgentId(agentId: string): {
+    evicted: number;
+    deferred: number;
+};
+/**
+ * Call when a pooled turn settles (success or error). If a credential change arrived mid-turn
+ * (pendingRecredential), evict now so the next turn respawns with the new credentials.
+ */
+export declare function settlePooledTurn(key: string): void;
 /** Kill + dispose every pooled agent and stop the reaper. Call on agent shutdown. */
 export declare function disposeAllPooledAgents(): void;
 export declare function pooledAgentCount(): number;

package/dist/types/runtime/infra/migrate-project-skills.d.ts

@@ -1,17 +1,20 @@
 /**
  * One-shot migration: fold legacy per-project skill directories
- * (`<projectRoot>/.qlogicagent/skills/<name>/`) into the single global store,
- * marking them project-scoped and enabling them in the originating project.
+ * (`<projectRoot>/.qlogicagent/skills/<name>/`) into the single global store.
  *
- * Idempotent — a no-op once the legacy directory is gone, so it is safe to call
- * on every project activation. Conflict-safe — if a DIFFERENT skill of the same
- * name already exists in the store, the legacy copy is LEFT IN PLACE with a loud
- * warning and never silently overwritten.
+ * Under the opt-out model every skill is global, so a freshly-migrated skill is parked GLOBALLY
+ * DISABLED — the same default as an agent-learned skill. The user re-enables it deliberately from
+ * the plugins page; a once-project-scoped skill must NOT silently light up in every project.
+ *
+ * Idempotent — a no-op once the legacy directory is gone, so it is safe to call on every project
+ * activation. Conflict-safe — if a DIFFERENT skill of the same name already exists in the store, the
+ * legacy copy is LEFT IN PLACE with a loud warning and never silently overwritten.
  */
 export interface SkillMigrationResult {
+    /** Moved into the store fresh (parked globally disabled). */
     migrated: string[];
     conflicts: string[];
-    /** Already present in the store with identical content; legacy copy reconciled. */
+    /** Already present in the store with identical content; legacy copy dropped, store entry untouched. */
     reconciled: string[];
 }
 /**

package/dist/types/runtime/infra/project-skill-manifest.d.ts

@@ -1,32 +1,20 @@
 /**
- * Project skill enablement manifest — the per-project opt-in list for the
- * single-store skill registry.
+ * Skill mute registries — under the single-store model, EVERY skill is global. There is no
+ * project-scoped / opt-in concept; instead there are two opt-OUT mute lists:
  *
- * Stored at `<cwd>/.qlogicagent/skills-enabled.json`:
- *   { "version": 1, "enabled": ["skill-a", "skill-b"] }
+ *   - owner-level  (~/.qlogicagent/profiles/<owner>/skills-disabled.json) — off in EVERY project
+ *     (the plugin card's on/off switch; also where agent-learned skills land, disabled, until the
+ *     user reviews and enables them).
+ *   - per-project  (<cwd>/.qlogicagent/skills-disabled.json)              — off in THIS project only
+ *     (the "project skills" opt-out, to cut down which skills an agent sees in a given project).
  *
- * Only project-scoped skills need listing here; globally-scoped skills
- * (see skill-lifecycle `enabledScope`) are active everywhere regardless.
+ *   active(project) = stored skill  AND  name ∉ globally-disabled  AND  name ∉ project-disabled
  */
-export interface ProjectSkillManifest {
-    version: 1;
-    enabled: string[];
-}
-/** Read the enablement manifest for a project. Returns empty manifest if absent/malformed. */
-export declare function readProjectSkillManifest(cwd: string): ProjectSkillManifest;
-/** The set of project-scoped skill names enabled in this project. */
-export declare function readEnabledSkills(cwd: string): Set<string>;
-/** Enable a (project-scoped) skill in this project. Idempotent. Returns true if newly added. */
-export declare function enableSkill(cwd: string, name: string): boolean;
-/** Disable (un-enable) a skill in this project. Idempotent. Returns true if removed. */
-export declare function disableSkill(cwd: string, name: string): boolean;
-/** Skills that are project-scoped (active only where a project manifest enables them). */
-export declare function readProjectScopedSkills(): Set<string>;
-/** Mark a skill project-scoped (learned/created). Idempotent. Returns true if newly added. */
-export declare function markProjectScoped(name: string): boolean;
-/** Unmark a skill (promote to global). Idempotent. Returns true if removed. */
-export declare function unmarkProjectScoped(name: string): boolean;
 /** Globally muted skills (inactive everywhere). */
 export declare function readGloballyDisabledSkills(): Set<string>;
-/** Mute/unmute a global skill everywhere. Idempotent. Returns true if the registry changed. */
+/** Mute/unmute a skill globally. Idempotent. Returns true if the registry changed. */
 export declare function setSkillGloballyDisabled(name: string, disabled: boolean): boolean;
+/** Skills muted in this project (inactive here, active elsewhere unless globally muted). */
+export declare function readProjectDisabledSkills(cwd: string): Set<string>;
+/** Mute/unmute a skill in this project. Idempotent. Returns true if the manifest changed. */
+export declare function setProjectSkillDisabled(cwd: string, name: string, disabled: boolean): boolean;

package/dist/types/runtime/infra/skill-resolver.d.ts

@@ -1,19 +1,15 @@
 /**
- * Skill resolver — single source of truth for "which skills are effective in a
- * given project" under the global-single-store + per-project-manifest model.
+ * Skill resolver — single source of truth for "which skills are effective in a given project".
  *
- * Storage: ONE global store at getUserSkillsDir(). A skill is project-scoped if
- * it appears in the owner-level project-scoped registry (skills-scoped.json);
- * otherwise it is global. Project-scoped skills are active only where the
- * project manifest (skills-enabled.json) lists them.
+ * Storage: ONE global store at getUserSkillsDir(). Every skill is global; two opt-out mute lists
+ * decide effectiveness — owner-level (off everywhere) and per-project (off in this project). See
+ * project-skill-manifest.
  *
- *   effective(project) = { store skills NOT marked project-scoped }
- *                      ∪ { project-scoped skills whose name ∈ project manifest }
+ *   active(project) = stored skill  AND  name ∉ globally-disabled  AND  name ∉ project-disabled
  *
- * All resolution / listing / injection surfaces MUST go through this module so
- * precedence and name-collision semantics live in exactly one place. Kept in
- * runtime/infra (no skills-layer imports) so both runtime and cli callers may
- * use it without crossing the runtime → skills boundary.
+ * All resolution / listing / injection surfaces MUST go through this module so precedence lives in
+ * exactly one place. Kept in runtime/infra (no skills-layer imports) so both runtime and cli callers
+ * may use it without crossing the runtime → skills boundary.
  */
 export interface ResolvedSkill {
     name: string;
@@ -21,8 +17,11 @@ export interface ResolvedSkill {
     filePath: string;
     /** Absolute path to <store>/<name> */
     baseDir: string;
-    enabledScope: "global" | "project";
-    /** Active in the resolution context: global, or project-enabled via manifest. */
+    /** Muted everywhere (the plugin card's off switch / agent-learned-pending-review). */
+    globallyDisabled: boolean;
+    /** Muted in THIS project's context (the per-project opt-out). */
+    projectDisabled: boolean;
+    /** Effective here: neither globally nor project muted. */
     active: boolean;
     systemGenerated: boolean;
     description?: string;
@@ -30,12 +29,11 @@ export interface ResolvedSkill {
 }
 export declare function isSystemGeneratedSkillName(name: string): boolean;
 /**
- * Resolve all skills in the global store, annotated with enablement scope and
- * whether they're active in the given project context.
+ * Resolve all skills in the global store, annotated with global/project mute state and whether
+ * they're active in the given project context.
  *
- * Returns ALL store skills (active and inactive) so listing surfaces can show
- * enable/disable state; callers that only want active skills filter `.active`
- * (or use resolveActiveSkills).
+ * Returns ALL store skills (active and inactive) so listing surfaces can show enable/disable state;
+ * callers that only want active skills filter `.active` (or use resolveActiveSkills).
  */
 export declare function resolveSkills(projectRoot?: string): ResolvedSkill[];
 /** Only the skills active in the given project (for prompt injection / resolution). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "2.15.6",
+  "version": "2.15.8",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",