qlogicagent 2.11.9 → 2.11.10

package/dist/types/runtime/infra/model-registry.d.ts

@@ -1,6 +1,6 @@
-import { type ReasoningMode } from "./provider-catalog-adapter.js";
 import { type KeyConfig, type KeyHandle, type LoadBalanceStrategy, type PoolStatus, type ProviderPoolConfig } from "./key-pool.js";
 export type RegistryChangeCallback = () => void;
+export type ReasoningMode = "none" | "adaptive" | "collapsed" | "effort";
 export type ModelPurpose = "textGeneration" | "smallModel" | "stt" | "tts" | "imageGeneration" | "imageUnderstanding" | "videoGeneration" | "videoUnderstanding" | "threeDGeneration" | "embedding" | "voiceClone" | "musicGeneration" | "realtimeAudio" | "realtimeVideo";
 export interface ModelInfo {
     id: string;
@@ -8,8 +8,9 @@ export interface ModelInfo {
     contextWindow?: number;
     maxOutput?: number;
     streamRequired?: boolean;
+    toolCall?: boolean;
     vision?: boolean;
-    mediaType?: string;
+    mediaType?: string | null;
 }
 export interface ProviderDef {
     id: string;
@@ -33,6 +34,8 @@ export interface ModelEntry {
     contextWindow?: number;
     maxOutput?: number;
     streamRequired?: boolean;
+    toolCall?: boolean;
+    mediaType?: string | null;
     capabilities?: string[];
     pricing?: Record<string, unknown>;
     /** Thinking-strength control class for the UI (see ReasoningMode). */
@@ -58,7 +61,7 @@ export interface ResolvedModel {
 export declare const ALL_PURPOSES: ModelPurpose[];
 export declare class ModelRegistry {
     private keyPool;
-    private providerCatalog;
+    private catalogProviders;
     private models;
     private modelEnabledOverrides;
     private bindings;
@@ -90,15 +93,9 @@ export declare class ModelRegistry {
     addModel(entry: Omit<ModelEntry, "id"> & {
         id?: string;
     }): string;
-    /**
-     * Backfill the reasoning control class for entries that arrived without it
-     * (e.g. from the llmrouter cloud catalog), using provider-core as the single
-     * source of truth. Entries that already carry reasoningMode are left as-is.
-     */
-    private withReasoningMode;
+    replaceCatalogProviders(providers: ProviderDef[]): void;
     replaceCatalogModels(entries: ModelEntry[]): void;
     replaceProviderModels(providerId: string, entries: ModelEntry[]): void;
-    migrateModelIds(aliasToNative: Map<string, string>): void;
     removeModel(id: string): void;
     enableModel(id: string): void;
     disableModel(id: string): void;
@@ -133,10 +130,8 @@ export declare class ModelRegistry {
     private resolveTechnicalVariant;
     private providerVariantKeyCandidates;
     private loadModelState;
-    private hydrateCatalogModels;
     private exportModelState;
     private emitChange;
 }
 export declare function getModelRegistry(): ModelRegistry;
 export declare function resetModelRegistry(): void;
-export declare function deriveModelPurposes(model: ModelInfo): ModelPurpose[];

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

@@ -0,0 +1,28 @@
+/**
+ * Project skill enablement manifest — the per-project opt-in list for the
+ * single-store skill registry.
+ *
+ * Stored at `<cwd>/.qlogicagent/skills-enabled.json`:
+ *   { "version": 1, "enabled": ["skill-a", "skill-b"] }
+ *
+ * Only project-scoped skills need listing here; globally-scoped skills
+ * (see skill-lifecycle `enabledScope`) are active everywhere regardless.
+ */
+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;

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

@@ -0,0 +1,51 @@
+/**
+ * Skill resolver — single source of truth for "which skills are effective in a
+ * given project" under the global-single-store + per-project-manifest model.
+ *
+ * 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.
+ *
+ *   effective(project) = { store skills NOT marked project-scoped }
+ *                      ∪ { project-scoped skills whose name ∈ project manifest }
+ *
+ * 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.
+ */
+export interface ResolvedSkill {
+    name: string;
+    /** Absolute path to <store>/<name>/SKILL.md */
+    filePath: string;
+    /** Absolute path to <store>/<name> */
+    baseDir: string;
+    enabledScope: "global" | "project";
+    /** Active in the resolution context: global, or project-enabled via manifest. */
+    active: boolean;
+    systemGenerated: boolean;
+    description?: string;
+    version?: string;
+}
+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.
+ *
+ * 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). */
+export declare function resolveActiveSkills(projectRoot?: string): ResolvedSkill[];
+/**
+ * Resolve a single skill by name to its store paths, or null if not present.
+ * Resolution honors only the global store (single source of truth) and ignores
+ * enablement — any stored skill is invocable by explicit name.
+ */
+export declare function resolveSkillPath(name: string): {
+    baseDir: string;
+    filePath: string;
+} | null;

package/dist/types/runtime/ports/agent-execution-contracts.d.ts

@@ -88,7 +88,7 @@ export type TurnEvent = {
 } | {
     type: "media_result";
     turnId: string;
-    mediaType: "image" | "tts" | "video" | "music";
+    mediaType: "image" | "tts" | "video" | "music" | "3d";
     url: string;
     model?: string;
     provider?: string;

package/dist/types/runtime/ports/path-service.d.ts

@@ -26,10 +26,7 @@ export interface PathService {
     getProjectAgentDir(projectRoot?: string): string;
     getProjectSettingsPath(projectRoot?: string): string;
     getProjectInstructionsPath(projectRoot?: string): string;
-    getProjectSkillsDir(projectRoot?: string): string;
     getProjectPluginsDir(projectRoot?: string): string;
     getProjectRulesDir(projectRoot?: string): string;
     getProjectSessionsRoot(projectRoot?: string): string;
-    getKnownProjectDirs(projectDirs: string[], excludeCwd?: string): string[];
-    getAllProjectSkillDirs(projectDirs: string[], excludeCwd?: string): string[];
 }

package/dist/types/skills/index.d.ts

@@ -1,7 +1,6 @@
 export type { PortableTool, PortableToolResult, ToolContentBlock, } from "./portable-tool.js";
 export { AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, filterToolsForAgent, } from "./tool-access.js";
-export type { ParsedSkillFrontmatter, WorkspaceSkill, SkillInstallSpec, SkillMetadata, SkillInvocationPolicy, SkillEntry, SkillCommandDispatchSpec, SkillCommandSpec, SkillSnapshot, SkillScanSeverity, SkillScanFinding, SkillScanSummary, SkillScanOptions, SkillFsDeps, SkillPathDeps, SkillLoadLimits, SkillSearchPaths, SkillLoaderDeps, } from "./skill-system/skill-types.js";
+export type { ParsedSkillFrontmatter, WorkspaceSkill, SkillInstallSpec, SkillMetadata, SkillInvocationPolicy, SkillCommandDispatchSpec, SkillCommandSpec, SkillScanSeverity, SkillScanFinding, SkillScanSummary, SkillScanOptions, SkillFsDeps, SkillPathDeps, } from "./skill-system/skill-types.js";
 export { parseFrontmatter, resolveSkillMetadata, resolveSkillInvocationPolicy, resolveSkillKey, } from "./skill-system/skill-frontmatter.js";
-export { loadSkillEntries, filterSkillEntries, buildSkillSnapshot, } from "./skill-system/skill-loader.js";
 export { scanSource, scanSkillDirectory, hasCriticalFindings, isScannable, } from "./skill-system/skill-guard.js";
 export type { SkillGuardDeps } from "./skill-system/skill-guard.js";

package/dist/types/skills/skill-system/skill-types.d.ts

@@ -72,15 +72,6 @@ export interface SkillInvocationPolicy {
     /** If true, the model cannot trigger this skill autonomously. */
     disableModelInvocation: boolean;
 }
-/**
- * A fully resolved skill entry with parsed metadata.
- */
-export interface SkillEntry {
-    skill: WorkspaceSkill;
-    frontmatter: ParsedSkillFrontmatter;
-    metadata?: SkillMetadata;
-    invocation?: SkillInvocationPolicy;
-}
 /**
  * Slash-command dispatch specification for a skill.
  */
@@ -98,19 +89,6 @@ export interface SkillCommandSpec {
     description: string;
     dispatch?: SkillCommandDispatchSpec;
 }
-/**
- * Serialized skill snapshot for system-prompt embedding.
- */
-export interface SkillSnapshot {
-    prompt: string;
-    skills: Array<{
-        name: string;
-        primaryEnv?: string;
-        requiredEnv?: string[];
-    }>;
-    skillFilter?: string[];
-    version?: number;
-}
 export type SkillScanSeverity = "info" | "warn" | "critical";
 export interface SkillScanFinding {
     ruleId: string;
@@ -160,40 +138,3 @@ export interface SkillPathDeps {
     extname(p: string): string;
     sep: string;
 }
-/**
- * Configurable limits for skill discovery to prevent abuse.
- */
-export interface SkillLoadLimits {
-    maxCandidatesPerRoot?: number;
-    maxSkillsLoadedPerSource?: number;
-    maxSkillsInPrompt?: number;
-    maxSkillsPromptChars?: number;
-    maxSkillFileBytes?: number;
-}
-/**
- * Search paths for skill discovery, ordered by precedence (low → high).
- */
-export interface SkillSearchPaths {
-    /** Bundled with npm package or app install. */
-    bundled?: string;
-    /** Extra directories from config. */
-    extra?: string[];
-    /** Managed skills (installed via CLI). */
-    managed?: string;
-    /** Personal agent skills: ~/.agents/skills/ */
-    personalAgents?: string;
-    /** Project agent skills: <workspace>/.agents/skills/ */
-    projectAgents?: string;
-    /** Workspace-level: <workspace>/skills/ */
-    workspace?: string;
-}
-/**
- * Aggregate deps for the skill loader.
- */
-export interface SkillLoaderDeps {
-    fs: SkillFsDeps;
-    path: SkillPathDeps;
-    homeDir: string;
-    searchPaths: SkillSearchPaths;
-    limits?: SkillLoadLimits;
-}

package/dist/types/transport/acp-server.d.ts

@@ -79,6 +79,8 @@ export interface AcpRequestHandler {
     handleAcpSoloSubscribe(params: Record<string, unknown>): Promise<unknown>;
     handleAcpSoloMessage(params: Record<string, unknown>): Promise<unknown>;
     handleAcpSoloEvaluate(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpSoloSpecChat(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpSoloSpecJudge(params: Record<string, unknown>): Promise<unknown>;
     handleAcpProductCreate(params: Record<string, unknown>): Promise<unknown>;
     handleAcpProductPlan(params: Record<string, unknown>): Promise<unknown>;
     handleAcpProductConfirm(params: Record<string, unknown>): Promise<unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "2.11.9",
+  "version": "2.11.10",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",
@@ -69,7 +69,7 @@
     "@agentclientprotocol/sdk": "^0.25.0",
     "@napi-rs/canvas": "0.1.100",
     "@xiaozhiclaw/pet-core": "0.1.0",
-    "@xiaozhiclaw/provider-core": "0.1.5",
+    "@xiaozhiclaw/provider-core": "0.1.6",
     "better-sqlite3": "^12.10.0",
     "dotenv": "^17.3.1",
     "nanoid": "^5.1.5",

package/dist/types/runtime/infra/provider-catalog-adapter.d.ts

@@ -1,69 +0,0 @@
-import { type ProviderVariantCapability } from "@xiaozhiclaw/provider-core";
-export type RuntimeProviderVariantCapability = ProviderVariantCapability;
-/**
- * How a model's thinking depth can be controlled, derived from provider-core
- * capabilities + quirks. The UI maps each mode to a different effort option set:
- *   - none      : model has no reasoning/thinking → hide the strength control
- *   - adaptive  : model self-regulates depth natively (Anthropic Opus/Sonnet
- *                 type:"adaptive") → only "智能"
- *   - collapsed : provider collapses effort levels (DeepSeek: low/medium→high,
- *                 high/xhigh→max) → "标准 / 最大" only
- *   - effort    : full granular control honored (o-series/Kimi reasoning_effort,
- *                 Anthropic budget thinking) → full 5 options
- */
-export type ReasoningMode = "none" | "adaptive" | "collapsed" | "effort";
-export interface RuntimeProviderCatalogProvider {
-    id: string;
-    name: string;
-    transport: string;
-    baseUrl: string;
-    defaultModel?: string;
-    group?: string;
-}
-export interface RuntimeProviderCatalogModel {
-    id: string;
-    name: string;
-    aliases?: string[];
-    contextWindow?: number;
-    maxOutput?: number;
-    streamRequired?: boolean;
-    toolCall?: boolean;
-    reasoning?: boolean;
-    vision?: boolean;
-    mediaType?: string;
-    costInput?: number;
-    costOutput?: number;
-    costCacheRead?: number;
-    costCacheWrite?: number;
-    pricing?: Record<string, unknown>;
-    /** Derived control class for thinking strength (see ReasoningMode). */
-    reasoningMode?: ReasoningMode;
-}
-export interface RuntimeProviderVariantResolutionInput {
-    publicModel: string;
-    requestedProtocol?: "openai-chat" | "openai-responses" | "anthropic-messages" | "volcengine-responses";
-    capabilities: RuntimeProviderVariantCapability[];
-    purpose: string;
-    userPreference?: {
-        providerIds?: string[];
-    };
-}
-export interface RuntimeProviderVariantResolution {
-    provider: string;
-    nativeModelId: string;
-}
-export declare class ProviderCatalogAdapter {
-    private readonly registry;
-    private readonly resolver;
-    getProvider(providerId: string): RuntimeProviderCatalogProvider | undefined;
-    listProviders(): RuntimeProviderCatalogProvider[];
-    listModels(providerId: string): RuntimeProviderCatalogModel[];
-    /**
-     * Classify a model's reasoning control from provider-core (the single source of
-     * truth), for entries sourced outside the builtin catalog (e.g. the llmrouter
-     * cloud catalog). Returns undefined when the model isn't a known provider-core
-     * model — callers should fall back to the granular default.
-     */
-    classifyReasoningMode(providerId: string, modelId: string): ReasoningMode | undefined;
-    resolveBest(input: RuntimeProviderVariantResolutionInput): RuntimeProviderVariantResolution | undefined;
-}

package/dist/types/skills/skill-system/skill-loader.d.ts

@@ -1,16 +0,0 @@
-import type { SkillEntry, SkillLoadLimits, SkillLoaderDeps, SkillSnapshot } from "./skill-types.js";
-/**
- * Discover all skills from configured search paths, applying precedence merge
- * and size/count limits. Returns fully parsed `SkillEntry` objects.
- */
-export declare function loadSkillEntries(deps: SkillLoaderDeps): SkillEntry[];
-/**
- * Filter skill entries by a name-based filter list.
- * If filter is undefined or empty, returns all entries.
- */
-export declare function filterSkillEntries(entries: SkillEntry[], skillFilter?: string[]): SkillEntry[];
-/**
- * Build a system-prompt-embeddable skill snapshot.
- * Applies count and character limits from the provided config.
- */
-export declare function buildSkillSnapshot(entries: SkillEntry[], limits?: SkillLoadLimits, skillFilter?: string[]): SkillSnapshot;