qlogicagent 2.16.4 → 2.16.6

package/dist/types/runtime/pet/pet-profile-service.d.ts

@@ -7,7 +7,7 @@ export interface PetPreferences {
 export interface PetdexPetAssetSummary {
     id: string;
     assetKind: "petdex";
-    sourceKind?: "builtin" | "upload" | "forge";
+    sourceKind?: "builtin" | "upload" | "forge" | "community";
     name: string;
     description: string;
     createdAt: string;
@@ -38,7 +38,7 @@ export interface PetdexPetAsset extends Omit<PetdexPetAssetSummary, "atlas"> {
     schema: "qlogic.petdex.asset.v1";
     atlas: PetdexPetAssetAtlas;
     source: {
-        kind: "builtin" | "upload" | "forge";
+        kind: "builtin" | "upload" | "forge" | "community";
         prompt: string | null;
     };
     animations: Record<PetdexAnimationId, PetdexPetAnimation>;

package/dist/types/runtime/pet/petdex-asset.d.ts

@@ -2,6 +2,8 @@ import { type PetdexAssetSource, type PetdexPetAsset, type PetdexValidationRepor
 export { PETDEX_SCHEMA, PETDEX_VALIDATION_SCHEMA, PETDEX_ATLAS_CONTRACT, PETDEX_ANIMATION_IDS, createDefaultPetdexAnimations, toPetdexAssetSummary, validatePetdexAssetManifest, petdexImageDataUrl, } from "@xiaozhiclaw/pet-core";
 export type { PetdexAnimationId, PetdexAnimation, PetdexAtlas, PetdexAssetSource, PetdexPetAsset, PetdexAssetManifest, PetdexPetAssetSummary, PetdexValidationReport, LoadedPetdexPackage, PetdexAssetPackage, PetdexAssetValidation, PetdexImportResult, } from "@xiaozhiclaw/pet-core";
 export declare function loadPetdexAssetPackage(filePath: string): Promise<LoadedPetdexPackage>;
+/** Load a `.petdex` package directly from its zip bytes (community install downloads it). */
+export declare function loadPetdexAssetPackageBytes(zip: Buffer): Promise<LoadedPetdexPackage>;
 export declare function buildPetdexAssetImport(filePath: string, targetDir: string): Promise<PetdexImportResult>;
 export declare function writePetdexAssetPackage(params: {
     asset: PetdexPetAsset;
@@ -11,6 +13,32 @@ export declare function writePetdexAssetPackage(params: {
     outputDir: string;
     fileName?: string;
 }): Promise<string>;
+/**
+ * Build a `.petdex` zip in memory (single source of truth for the package layout).
+ * Community publish gzips these bytes for Hub OSS; writePetdexAssetPackage lands them on disk.
+ * Validation is recomputed from asset+spritesheet so the embedded validation.json always matches.
+ */
+export declare function buildPetdexAssetPackageBytes(params: {
+    asset: PetdexPetAsset;
+    spritesheet: Buffer;
+    productionRun?: unknown;
+}): Buffer;
+/**
+ * Package a petdex asset for community publish: the gzipped `.petdex` blob (the exact wire
+ * format Hub OSS serves at downloadUrl, which the installer gunzips) plus a v15 asset manifest
+ * carrying the petdex asset descriptor. The hub derives checksum + sizeBytes from the decoded
+ * blob server-side, so neither is sent here.
+ */
+export declare function buildPetdexPublishPayload(params: {
+    asset: PetdexPetAsset;
+    spritesheet: Buffer;
+    version?: string;
+    tags?: string[];
+}): {
+    manifest: Record<string, unknown>;
+    version: string;
+    packageGzipBase64: string;
+};
 export declare function createPetdexAssetFromSpritesheet(params: {
     id?: string;
     name: string;

package/dist/types/runtime/ports/tool-contracts.d.ts

@@ -26,7 +26,6 @@ export interface RuntimeToolContract {
     isEgress?: boolean;
     egressCarriesData?: boolean;
     isEnabled?: () => boolean;
-    shouldDefer?: boolean;
     execute?(toolCallId: string, params: any, signal?: AbortSignal): Promise<{
         content: Array<{
             type: "text" | "image";
@@ -40,20 +39,12 @@ export interface RuntimeToolContract {
 }
 export interface ToolCatalog {
     findTool(name: string): RuntimeToolContract | undefined;
-    getToolManifest(includeDeferred?: boolean): ToolDefinition[];
+    getToolManifest(): ToolDefinition[];
     getToolNames(): string[];
     setTools(tools: RuntimeToolContract[]): void;
     addTool(tool: RuntimeToolContract): void;
     addTools(tools: RuntimeToolContract[]): void;
     removeTool(name: string): boolean;
-    activateTool(name: string): boolean;
-    clearActivatedTools(): void;
-    /** SSOT for the deferred-tool set consumed by the prompt index and the tool_search corpus. */
-    listDeferredTools(): Array<{
-        name: string;
-        description: string;
-        searchHint?: string;
-    }>;
 }
 export interface ToolBootstrapProgress {
     output: string;

package/dist/types/runtime/prompt/environment-context.d.ts

@@ -35,37 +35,6 @@ export declare function createTaskGuidanceSection(domain?: TaskDomain): SystemPr
  * Tells the LLM when to use specialized tools vs. primitives.
  */
 export declare function createToolGuidanceSection(): SystemPromptSection;
-type DeferredIndexEntry = {
-    name: string;
-    description: string;
-    searchHint?: string;
-};
-/**
- * Render the deferred-tool listing with accuracy-aware token discipline.
- *
- * Dropping ALL descriptions to save tokens trades away tool-SELECTION accuracy:
- * the model cannot tell `mcp__exa__search` from `mcp__github__search` by name.
- * So spend the description budget exactly where confusion lives:
- *   - small set (<= richHintLimit): every tool rich.
- *   - built-in deferred tools (no server): always rich — small, bounded set.
- *   - MCP tools whose leaf name collides with another tool: keep the hint.
- *   - MCP tools with a unique leaf: name only (unambiguous; tool_search recovers
- *     details on demand).
- * Names are ALWAYS listed so any capability can be `select:`ed directly.
- */
-export declare function buildDeferredToolIndexBody(deferred: DeferredIndexEntry[], richHintLimit: number): string[];
-/**
- * Index of deferred tools so the model KNOWS these capabilities exist even
- * though their schemas are not loaded. Without this the model sees only the
- * non-deferred tool list and will wrongly claim it lacks e.g. video generation.
- *
- * Volatile (recomputed each turn) because the deferred set can change when
- * dynamic registrations (MCP, session bootstrap) land; the rendered text is
- * stable across turns otherwise, so prompt cache is preserved in practice.
- */
-export declare function createDeferredToolIndexSection(listDeferredTools: () => DeferredIndexEntry[], options?: {
-    richHintLimit?: number;
-}): SystemPromptSection;
 /**
  * Create a system prompt section that instructs the model on response language.
  * CC parity: only injected when language is explicitly set; when absent,
@@ -76,6 +45,14 @@ export declare function createDeferredToolIndexSection(listDeferredTools: () =>
  * (e.g., Chinese INDEX.md + English tool guidance).
  */
 export declare function createLanguageSection(language?: string): SystemPromptSection;
+/**
+ * Available Skills — CC skill-discovery parity. Lists every active (installed, not muted) skill
+ * with its description (hermes-style, description-only), and tells the model to load a matching
+ * skill via skill_view BEFORE acting — even when the user did not name it. This is the link that
+ * makes installed skills actually auto-activate; without it active skills only sit behind the
+ * skill_view tool as a passive catalog and never fire on their own.
+ */
+export declare function createAvailableSkillsSection(cwdOverride?: string): SystemPromptSection;
 /**
  * Detect the response language from the user's current-turn text so the strong
  * explicit-language branch of createLanguageSection actually fires.
@@ -87,4 +64,3 @@ export declare function createLanguageSection(language?: string): SystemPromptSe
  * fallback handle English/other, which weak models already mirror fine).
  */
 export declare function detectResponseLanguage(userText: string): string | undefined;
-export {};

package/dist/types/runtime/tasks/task-types.d.ts

@@ -15,7 +15,6 @@
  * PRODUCED today (have a real registration site):
  * - local_bash:   backgrounded shell command (BackgroundTaskManager.registerBashTask)
  * - local_agent:  backgrounded forked agent     (BackgroundTaskManager.startAgentTask)
- * - team_member:  long-lived team subprocess     (team-tool-service → registerExternalTask)
  * - dream:        memory consolidation           (runDream → taskStore.registerTask)
  *
  * PLANNED — declared for the TASK_PREFIX taxonomy + UI/protocol contract, but NO
@@ -24,13 +23,8 @@
  * - remote_agent:    cloud sandbox (polling-based)
  * - local_workflow:  DAG/pipeline execution
  * - monitor_mcp:     MCP server monitoring agent
- *
- * Naming note: we deliberately diverge from upstream CC's `in_process_teammate`.
- * Our team members run as isolated SUBPROCESSES (AgentProcessManager) in their own
- * git worktrees, not AsyncLocalStorage in-process agents — so the honest name is
- * `team_member`. Keeps the `t` task-id prefix.
  */
-export type TaskType = "local_bash" | "local_agent" | "remote_agent" | "team_member" | "local_workflow" | "monitor_mcp" | "dream";
+export type TaskType = "local_bash" | "local_agent" | "remote_agent" | "local_workflow" | "monitor_mcp" | "dream";
 /**
  * How a sub-agent is isolated from the parent execution.
  *
@@ -115,22 +109,6 @@ export interface RemoteAgentTaskState extends TaskStateBase {
     /** Polling endpoint for status checks. */
     pollEndpoint?: string;
 }
-/** Team member — long-lived collaborator subprocess in its own git worktree. */
-export interface TeamMemberTaskState extends TaskStateBase {
-    type: "team_member";
-    /** Team this member belongs to. */
-    teamName: string;
-    /** Member's display name. */
-    agentName: string;
-    /** Stable member id (`team-<team>-<name>`) — routes team send / cancel. */
-    memberId: string;
-    /** Subprocess PID, once spawned. */
-    pid?: number;
-    /** Isolated git worktree path (when provisioned). */
-    worktreePath?: string;
-    /** Worktree branch name (for cleanup). */
-    worktreeBranch?: string;
-}
 /** A single dream agent turn — text output + tool use count. */
 export interface DreamTurn {
     text: string;
@@ -158,14 +136,6 @@ export interface PlannedTaskState extends TaskStateBase {
     type: "local_workflow" | "monitor_mcp";
 }
 /** Union of all concrete task states. */
-export type TaskState = LocalBashTaskState | LocalAgentTaskState | RemoteAgentTaskState | TeamMemberTaskState | DreamTaskState | PlannedTaskState;
-/**
- * Filter available tools by permission role.
- *
- * @param role - The agent's permission role
- * @param availableTools - Full set of tool names
- * @returns Filtered tool names appropriate for the role
- */
-export declare function filterToolsByRole(role: PermissionRole, availableTools: string[]): string[];
+export type TaskState = LocalBashTaskState | LocalAgentTaskState | RemoteAgentTaskState | DreamTaskState | PlannedTaskState;
 /** Create a new task state with defaults populated. */
 export declare function createTaskState(overrides: Pick<TaskStateBase, "taskId" | "type" | "label"> & Partial<TaskStateBase>): TaskStateBase;

package/dist/types/skills/mcp/mcp-manager.d.ts

@@ -21,10 +21,19 @@ export interface McpServerEntry {
     url?: string;
     /** Extra HTTP headers (http only) */
     headers?: Record<string, string>;
-    /** Init timeout (ms) — accepted for config compatibility; mcporter owns connect timeouts. */
-    initTimeoutMs?: number;
     /** Whether this server is disabled (skip connection) */
     disabled?: boolean;
+    /** Allow the MCP runtime to start an OAuth flow for this server; default is cached-token/headless only. */
+    oauth?: boolean;
+    /** Optional tool-name allow/deny filters applied after connect-time discovery. */
+    tools?: {
+        include?: string[];
+        exclude?: string[];
+    };
+}
+export interface McpSecurityIssue {
+    code: "dangerous_egress" | "persistence" | "ioc_public_key";
+    message: string;
 }
 export interface McpManagerConfig {
     servers: McpServerEntry[];
@@ -45,6 +54,8 @@ export declare class McpManager {
     private log;
     private workspaceRoot?;
     private toolCatalog?;
+    private serverToolFilters;
+    private serverOAuth;
     constructor(config: McpManagerConfig);
     private toServerDefinition;
     /**
@@ -56,6 +67,7 @@ export declare class McpManager {
      * Register all snapshotted MCP tools into the tool pool.
      */
     injectTools(): void;
+    refreshServerTools(serverName: string): Promise<number>;
     /** Get names of all connected servers. */
     getConnectedServers(): string[];
     /** Get total number of MCP tools across all servers. */
@@ -67,9 +79,15 @@ export declare class McpManager {
     disconnectAll(): Promise<void>;
     private toPortableTool;
     private wrapToolsForWorkspaceBoundary;
+    private injectPortableTools;
+    private retractServerTools;
     private registerTools;
     private removeRegisteredTool;
 }
 export declare function validateMcpToolWorkspaceBoundary(toolName: string, args: unknown, workspaceRoot: string | undefined): string | null;
 export declare function parseMcpConfig(json: unknown): McpServerEntry[];
+export declare function filterMcpTools<T extends {
+    name: string;
+}>(tools: readonly T[], filter?: McpServerEntry["tools"]): T[];
+export declare function validateMcpServerSecurity(entry: McpServerEntry): McpSecurityIssue[];
 export {};

package/dist/types/skills/permissions/hook-runner.d.ts

@@ -43,13 +43,6 @@ export interface PermissionCheckerDeps {
     sessionId?: string;
     /** Getter for current turn ID (changes per turn). */
     getTurnId?: () => string;
-    /** Best-effort community telemetry sink for consent-gated sandbox metrics. */
-    communityTelemetryRecorder?: {
-        recordTelemetry(input: {
-            event: "community.sandbox.violation";
-            metadata?: Record<string, unknown>;
-        }): Promise<unknown>;
-    };
 }
 export declare class PermissionChecker {
     private readonly ruleEngine;
@@ -64,15 +57,6 @@ export declare class PermissionChecker {
     private readonly auditLogger;
     private readonly sessionId;
     private readonly getTurnId;
-    private readonly communityTelemetryRecorder;
-    private readonly communitySandboxTurnIds;
-    /**
-     * cut7c — community-skill (untrusted) scoped deny/ask rules, passed per-call as
-     * `ruleEngine.check(..., { extraRules })` for community turns. NOT a second engine:
-     * the single rule engine evaluates these alongside the base rules. FS/exec tools are
-     * absent here → they flow through the unified pipeline (workspace + prompt + OS sandbox).
-     */
-    private readonly communityScopedRules;
     private unregisterHook;
     /** Tool meta cache — populated from ToolDefinition[] at agent creation */
     private toolMetaCache;
@@ -95,12 +79,6 @@ export declare class PermissionChecker {
      */
     setToolMeta(tools: ToolDefinition[]): void;
     get ruleEngineRef(): PermissionRuleEngine;
-    /**
-     * cut7c — whether the CURRENT turn is a community-skill (untrusted) turn. Consumed by
-     * the OS-sandbox builder to tighten community execs (netPolicy=deny: no outbound network
-     * from the sandboxed child) as defense-in-depth on POSIX.
-     */
-    isCommunitySandboxTurn(): boolean;
     /** Fire permission.denied hook + onDenied callback + audit log */
     private fireDenied;
     private handleResult;

package/dist/types/skills/plugins/plugin-api.d.ts

@@ -11,7 +11,7 @@ export interface PluginApi {
     registerHook(phase: PluginHookPhase, handler: HookHandler<any>): void;
     /** Register a skill (Markdown instructions + metadata). */
     registerSkill(skill: WorkspaceSkill): void;
-    /** Get plugin-scoped configuration (from openclaw/plugins/name/config.json). */
+    /** Get plugin-scoped configuration (from xiaozhiclaw/plugins/name/config.json). */
     getConfig(): Record<string, unknown>;
     /**
      * Set an activation check function. When it returns false, the plugin's

package/dist/types/skills/portable-tool.d.ts

@@ -66,13 +66,6 @@ export interface PortableTool<TParams = Record<string, unknown>> {
     description: string;
     /** JSON Schema object describing the tool's parameters. */
     parameters: Record<string, unknown>;
-    /**
-     * When true, the tool should NOT appear in the default tool list.
-     * The host injects it only for complex tasks (e.g. multi-step reasoning)
-     * or when explicitly activated via tool_search.
-     * This saves context tokens in simple conversations.
-     */
-    shouldDefer?: boolean;
     /**
      * Whether the tool can safely run concurrently with other tools.
      * When true, the runtime may execute this tool in parallel with others.
@@ -132,8 +125,9 @@ export interface PortableTool<TParams = Record<string, unknown>> {
         reason?: string;
     };
     /**
-     * Brief keyword hint for tool_search to match against
+     * Brief keyword hint describing the tool's intent
      * (e.g. "return the final response as structured JSON").
+     * Carried as capability metadata for UI/search surfaces.
      */
     searchHint?: string;
     /**

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

@@ -0,0 +1,8 @@
+export interface SkillBundle {
+    name: string;
+    skills: string[];
+    filePath: string;
+}
+export declare function getSkillBundlesDir(): string;
+export declare function listSkillBundles(bundleDir?: string): SkillBundle[];
+export declare function resolveSkillBundle(name: string, bundleDir?: string): SkillBundle | undefined;

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

@@ -1,4 +1,4 @@
-import type { ParsedSkillFrontmatter, SkillInvocationPolicy, SkillMetadata } from "./skill-types.js";
+import type { ParsedSkillFrontmatter, SkillMetadata } from "./skill-types.js";
 /**
  * Parse a YAML-like frontmatter block into a flat key→value record.
  * Uses a lightweight line parser to avoid a YAML library dependency.
@@ -9,10 +9,6 @@ export declare function parseFrontmatter(content: string): ParsedSkillFrontmatte
  * Expects `metadata: {"openclaw": {...}}` (JSON format).
  */
 export declare function resolveSkillMetadata(frontmatter: ParsedSkillFrontmatter): SkillMetadata | undefined;
-/**
- * Resolve invocation policy from frontmatter fields.
- */
-export declare function resolveSkillInvocationPolicy(frontmatter: ParsedSkillFrontmatter): SkillInvocationPolicy;
 /**
  * Get the canonical key for a skill (metadata.skillKey or skill.name).
  */

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

@@ -10,6 +10,8 @@ export interface SkillLifecycleRecord {
     archivedAt?: string;
     pinned: boolean;
     useCount: number;
+    positiveCount?: number;
+    negativeCount?: number;
     source: "learned" | "created" | "installed" | "promoted";
     resourceType?: string;
     launcherRequired?: boolean;
@@ -28,6 +30,14 @@ export interface SkillLifecycleStore {
     version: 1;
     records: Record<string, SkillLifecycleRecord>;
 }
+export interface SkillUsageStats {
+    invokeCount: number;
+    activeCount: number;
+    positiveCount: number;
+    negativeCount: number;
+    lastUsedAt?: string;
+    successRate?: number;
+}
 export interface CuratorResult {
     transitioned: Array<{
         name: string;
@@ -45,7 +55,7 @@ export declare function ensureRecord(store: SkillLifecycleStore, name: string, s
 /**
  * Record a skill invocation — resets to active if stale.
  */
-export declare function recordInvocation(store: SkillLifecycleStore, name: string): void;
+export declare function recordInvocation(store: SkillLifecycleStore, name: string, success?: boolean): void;
 /**
  * Record that a skill was viewed/listed.
  */
@@ -87,6 +97,8 @@ export declare function getSkillsByState(store: SkillLifecycleStore, state: Skil
  * Get lifecycle record for a skill. Returns undefined if not tracked.
  */
 export declare function getLifecycleRecord(store: SkillLifecycleStore, name: string): SkillLifecycleRecord | undefined;
+export declare function getLifecycleSkillStats(store: SkillLifecycleStore, name: string): SkillUsageStats | undefined;
+export declare function getAllLifecycleSkillStats(store: SkillLifecycleStore): Record<string, SkillUsageStats>;
 /**
  * Remove a lifecycle record (e.g., when skill is deleted).
  */

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

@@ -0,0 +1,11 @@
+export interface SkillTemplateVars {
+    skillDir?: string;
+    sessionId?: string;
+}
+export interface SkillPreprocessOptions extends SkillTemplateVars {
+    inlineShell?: boolean;
+    runInlineShellCommand?: (command: string) => Promise<string>;
+    maxInlineShellOutput?: number;
+}
+export declare function preprocessSkillContent(content: string, options?: SkillPreprocessOptions): Promise<string>;
+export declare function substituteSkillTemplateVars(content: string, vars?: SkillTemplateVars): string;

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

@@ -63,78 +63,3 @@ export interface SkillMetadata {
     };
     install?: SkillInstallSpec[];
 }
-/**
- * Controls how a skill may be activated by user commands or model tool calls.
- */
-export interface SkillInvocationPolicy {
-    /** Whether users can directly invoke this skill via slash-command. */
-    userInvocable: boolean;
-    /** If true, the model cannot trigger this skill autonomously. */
-    disableModelInvocation: boolean;
-}
-/**
- * Slash-command dispatch specification for a skill.
- */
-export interface SkillCommandDispatchSpec {
-    kind: "tool";
-    toolName: string;
-    argMode?: "raw";
-}
-/**
- * A skill-derived slash-command for IM platforms.
- */
-export interface SkillCommandSpec {
-    name: string;
-    skillName: string;
-    description: string;
-    dispatch?: SkillCommandDispatchSpec;
-}
-export type SkillScanSeverity = "info" | "warn" | "critical";
-export interface SkillScanFinding {
-    ruleId: string;
-    severity: SkillScanSeverity;
-    file: string;
-    line: number;
-    message: string;
-    evidence: string;
-}
-export interface SkillScanSummary {
-    scannedFiles: number;
-    critical: number;
-    warn: number;
-    info: number;
-    findings: SkillScanFinding[];
-}
-export interface SkillScanOptions {
-    includeFiles?: string[];
-    maxFiles?: number;
-    maxFileBytes?: number;
-}
-/**
- * Filesystem dependencies injected by the host runtime.
- * Keeps the skill system decoupled from Node.js `fs` / `path`.
- */
-export interface SkillFsDeps {
-    readFileSync(path: string, encoding: "utf-8"): string;
-    readFile(path: string, encoding: "utf-8"): Promise<string>;
-    existsSync(path: string): boolean;
-    statSync(path: string): {
-        size: number;
-        mtimeMs: number;
-        isDirectory(): boolean;
-    };
-    readdirSync(path: string, opts: {
-        withFileTypes: true;
-    }): Array<{
-        name: string;
-        isDirectory(): boolean;
-        isSymbolicLink(): boolean;
-    }>;
-    realpathSync(path: string): string;
-}
-export interface SkillPathDeps {
-    join(...segments: string[]): string;
-    resolve(...segments: string[]): string;
-    extname(p: string): string;
-    sep: string;
-}

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

@@ -5,6 +5,7 @@ export interface FrontmatterValidationResult {
     /** Parsed frontmatter if valid. */
     parsed?: Record<string, string>;
 }
+export declare const MAX_DESCRIPTION_LENGTH = 60;
 /**
  * Validate SKILL.md content for required frontmatter structure.
  * Used before persisting agent-created skills.

package/dist/types/skills/tools/skill-tool.d.ts

@@ -1,11 +1,20 @@
 import type { PortableTool } from "../portable-tool.js";
 import type { WorkspaceSkill } from "../skill-system/skill-types.js";
-export declare const SKILL_TOOL_NAME: "skill";
-export type SkillAction = "invoke" | "list" | "view" | "create" | "edit" | "patch" | "delete" | "promote";
-export interface SkillToolParams {
-    action: SkillAction;
-    name?: string;
+export declare const SKILL_VIEW_TOOL_NAME: "skill_view";
+export declare const SKILLS_LIST_TOOL_NAME: "skills_list";
+export declare const SKILL_MANAGE_TOOL_NAME: "skill_manage";
+export type SkillManageAction = "create" | "edit" | "patch" | "delete" | "promote";
+export interface SkillViewParams {
+    name: string;
     args?: string;
+    filePath?: string;
+}
+export interface SkillsListParams {
+    category?: string;
+}
+export interface SkillManageParams {
+    action: SkillManageAction;
+    name: string;
     category?: string;
     content?: string;
     filePath?: string;
@@ -13,25 +22,49 @@ export interface SkillToolParams {
     oldString?: string;
     newString?: string;
 }
-export declare const SKILL_TOOL_SCHEMA: {
+export declare const SKILL_VIEW_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "The skill to use. Calling skill_view(name='X') loads that skill and you follow its instructions in THIS turn — that single call is all you need to USE a skill.";
+        };
+        readonly args: {
+            readonly type: "string";
+            readonly description: "Optional context/arguments to pass to the skill.";
+        };
+        readonly filePath: {
+            readonly type: "string";
+            readonly description: "Optional path of a supporting file inside the skill folder to read instead of running the skill (e.g. a reference doc or script). When omitted, the skill is loaded and run.";
+        };
+    };
+    readonly required: readonly ["name"];
+};
+export declare const SKILLS_LIST_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly category: {
+            readonly type: "string";
+            readonly description: "Optional category filter.";
+        };
+    };
+    readonly required: readonly [];
+};
+export declare const SKILL_MANAGE_TOOL_SCHEMA: {
     readonly type: "object";
     readonly properties: {
         readonly action: {
             readonly type: "string";
-            readonly enum: readonly ["invoke", "list", "view", "create", "edit", "patch", "delete", "promote"];
+            readonly enum: readonly ["create", "edit", "patch", "delete", "promote"];
             readonly description: string;
         };
         readonly name: {
             readonly type: "string";
-            readonly description: "Skill name (required for invoke/view/create/edit/patch/delete/promote).";
-        };
-        readonly args: {
-            readonly type: "string";
-            readonly description: "Arguments or context to pass when invoking a skill.";
+            readonly description: "The skill name to author or manage.";
         };
         readonly category: {
             readonly type: "string";
-            readonly description: "Filter skills by category (for 'list' action).";
+            readonly description: "Optional category label for create/edit.";
         };
         readonly content: {
             readonly type: "string";
@@ -39,22 +72,22 @@ export declare const SKILL_TOOL_SCHEMA: {
         };
         readonly filePath: {
             readonly type: "string";
-            readonly description: "Path of a file inside the skill folder: read it (view) or write it with fileContent (create/edit). SKILL.md itself always goes through 'content'.";
+            readonly description: "Path of a file inside the skill folder to write with fileContent (create/edit). SKILL.md itself always goes through 'content'.";
         };
         readonly fileContent: {
             readonly type: "string";
-            readonly description: "Supporting file content. With filePath, writes that file inside the skill folder (create: alongside SKILL.md; edit: file-only update).";
+            readonly description: "Supporting file content. With filePath, writes that file inside the skill folder.";
         };
         readonly oldString: {
             readonly type: "string";
-            readonly description: "Text to find for patch action.";
+            readonly description: "Text to find for the patch action.";
         };
         readonly newString: {
             readonly type: "string";
-            readonly description: "Replacement text for patch action.";
+            readonly description: "Replacement text for the patch action.";
         };
     };
-    readonly required: readonly ["action"];
+    readonly required: readonly ["action", "name"];
 };
 export interface SkillListItem {
     name: string;
@@ -71,6 +104,7 @@ export interface SkillListOutput {
 export interface SkillViewOutput {
     name: string;
     content: string;
+    skillDir?: string;
     referenceFiles?: string[];
 }
 export interface SkillManageResult {
@@ -81,14 +115,14 @@ export interface SkillManageResult {
 export interface SkillToolDeps {
     /** List all available skills (Layer 0 metadata). */
     listSkills(): WorkspaceSkill[];
-    /** List skills with full detail (for list action). */
+    /** List skills with full detail (for skills_list). */
     listSkillsFull(category?: string): Promise<SkillListOutput>;
     /** Read skill content (Layer 1 instructions). */
     readSkillContent(name: string): Promise<string | null>;
     /** View skill with optional file path. */
     viewSkill(name: string, filePath?: string): Promise<SkillViewOutput | null>;
-    /** Execute skill as sub-turn. */
-    executeSkillSubturn?(skillName: string, skillContent: string, userArgs: string | undefined, signal?: AbortSignal): Promise<string>;
+    /** Run a skill — returns its instructions for the main model to follow inline (mainstream, no sub-turn). */
+    runSkillInvocation(skillName: string, skillContent: string, userArgs: string | undefined, skillDir: string | undefined, signal?: AbortSignal): Promise<string>;
     /** Manage skill (create/edit/patch/delete). */
     manageSkill(params: {
         action: string;
@@ -103,4 +137,6 @@ export interface SkillToolDeps {
     /** Promote a project-level skill to user/global level. Returns success message. */
     promoteSkill?(name: string): Promise<SkillManageResult>;
 }
-export declare function createSkillMetaTool(deps: SkillToolDeps): PortableTool<SkillToolParams>;
+export declare function createSkillViewTool(deps: SkillToolDeps): PortableTool<SkillViewParams>;
+export declare function createSkillsListTool(deps: SkillToolDeps): PortableTool<SkillsListParams>;
+export declare function createSkillManageTool(deps: SkillToolDeps): PortableTool<SkillManageParams>;