qlogicagent 2.16.3 → 2.16.5

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/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/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;
@@ -81,14 +114,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, signal?: AbortSignal): Promise<string>;
     /** Manage skill (create/edit/patch/delete). */
     manageSkill(params: {
         action: string;
@@ -103,4 +136,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>;

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

@@ -5,27 +5,16 @@
  * New runtime code should depend on a ToolCatalog/ToolRegistry instance; the
  * module-level functions below remain as a compatibility facade for older
  * bootstrap paths while those call sites are migrated.
+ *
+ * All registered tools are resident: every enabled tool is offered to the model
+ * each turn (hermes-aligned). There is no deferral / on-demand discovery.
  */
 import type { PortableTool } from "./portable-tool.js";
 import type { ToolDefinition } from "../protocol/wire/index.js";
 import { AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, filterToolsForAgent } from "./tool-access.js";
 export { AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, filterToolsForAgent };
-/**
- * Deferral policy (CC-aligned): a few HIGH-FREQUENCY capabilities stay LOADED even if their
- * factory marks them deferrable, so the model never has to voluntarily tool_search for the
- * things users ask for most. Only the long tail (rare media variants, niche tools) and MCP
- * stay deferred. Trades a small always-on token cost on common paths for discovery
- * reliability — mirrors Claude Code (keeps common tools loaded; defers only the long
- * tail / large MCP sets) rather than relying on the model to decide to search.
- */
-export declare const COMMON_LOADED_CAPABILITIES: Set<string>;
 export declare class ToolRegistry {
     private readonly toolPool;
-    private readonly activatedTools;
-    private readonly maxActivatedDeferred;
-    constructor(options?: {
-        maxActivatedDeferred?: number;
-    });
     setTools(tools: PortableTool[]): void;
     addTool(tool: PortableTool<any>): void;
     addTools(tools: PortableTool<any>[]): void;
@@ -36,22 +25,7 @@ export declare class ToolRegistry {
     getToolCount(): number;
     executeTool(name: string, toolCallId: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<import("./portable-tool.js").PortableToolResult>;
     getTools(): PortableTool[];
-    activateTool(name: string): boolean;
-    isToolActivated(name: string): boolean;
-    clearActivatedTools(): void;
-    /**
-     * SSOT for "which tools are deferred". Both the deferred-tool index (system
-     * prompt) and the tool_search corpus consume this — never re-derive the
-     * deferred set inline. Lists every deferred+enabled tool regardless of
-     * activation, so the model can always see/search a capability that exists.
-     * searchHint is carried for the search corpus; the prompt index ignores it.
-     */
-    listDeferredTools(): Array<{
-        name: string;
-        description: string;
-        searchHint?: string;
-    }>;
-    getToolManifest(includeDeferred?: boolean): ToolDefinition[];
+    getToolManifest(): ToolDefinition[];
 }
 export declare function getDefaultToolRegistry(): ToolRegistry;
 export declare function setToolPool(tools: PortableTool[]): void;
@@ -64,12 +38,4 @@ export declare function getToolNames(): string[];
 export declare function getToolCount(): number;
 export declare function executeTool(name: string, toolCallId: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<import("./portable-tool.js").PortableToolResult>;
 export declare function getTools(): PortableTool[];
-export declare function activateTool(name: string): boolean;
-export declare function isToolActivated(name: string): boolean;
-export declare function clearActivatedTools(): void;
-export declare function listDeferredTools(): Array<{
-    name: string;
-    description: string;
-    searchHint?: string;
-}>;
-export declare function getToolManifest(includeDeferred?: boolean): ToolDefinition[];
+export declare function getToolManifest(): ToolDefinition[];

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

@@ -2,7 +2,7 @@
  * ACP ServerAgent-Client Protocol server layer for qlogicagent.
  *
  * This module implements qlogicagent as an ACP Server, allowing any ACP-compliant
- * host (AionUI, Cursor, openclaw, etc.) to connect and interact with the agent.
+ * host (AionUI, Cursor, xiaozhiclaw, etc.) to connect and interact with the agent.
  *
  * Protocol: ACP v1 over JSON-RPC 2.0 / stdio (line-delimited JSON).
  *
@@ -94,6 +94,18 @@ export interface AcpRequestHandler {
     handleAcpProductReplay(params: Record<string, unknown>): Promise<unknown>;
     handleAcpProductStatus(params: Record<string, unknown>): Promise<unknown>;
     handleAcpProductSubscribe(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpGoalStart(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpGoalStatus(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpGoalPause(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpGoalResume(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpGoalUpdateGoal(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpGoalStop(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpGoalMessage(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpGoalSubscribe(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpGoalEvents(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpMentionDelegate(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpMentionCancel(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpMentionList(params: Record<string, unknown>): Promise<unknown>;
 }
 export interface AcpServerConfig {
     verbose?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "2.16.3",
+  "version": "2.16.5",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",
@@ -80,7 +80,6 @@
     "check:workspace-hygiene:strict": "node scripts/check-workspace-hygiene.mjs --strict",
     "check:package-artifact": "npm run build && node scripts/check-package-artifact.mjs",
     "redteam:community-desensitization": "tsx src/runtime/community/community-desensitization-red-team-cli.ts",
-    "redteam:community-sandbox": "tsx src/skills/permissions/community-sandbox-red-team-cli.ts",
     "clean:workspace-hygiene": "node scripts/clean-workspace-hygiene.mjs",
     "release": "node scripts/release.mjs"
   },

package/dist/types/cli/core-tools/team-registry.d.ts

@@ -1,62 +0,0 @@
-/**
- * TeamRegistry — session-scoped roster for the team tool: create registers
- * members (producer), the send action routes messages to them (consumer).
- *
- * The team tool spawns each member as a real subprocess agent
- * (AgentProcessManager) and registers a delivery closure here. The send
- * action looks the target up by name or full member id and routes the message
- * into the member's process via that closure, returning the member's reply.
- *
- * This registry is the ONLY routing path to team members, so an
- * unregistered/dead target fails loud.
- */
-export interface TeamRegistryMember {
-    /** Full member id, e.g. "team-research-coder". */
-    memberId: string;
-    /** Display name within the team, e.g. "coder". */
-    name: string;
-    /** Team this member belongs to. */
-    teamName: string;
-    /** Role description. */
-    role: string;
-    /** Deliver a message into the member's process and return its reply text. */
-    deliver: (message: string, fromId: string) => Promise<string>;
-    /** Whether the member's process is still alive. */
-    isAlive: () => boolean;
-}
-export interface TeamRegistryListEntry {
-    memberId: string;
-    name: string;
-    teamName: string;
-    role: string;
-    alive: boolean;
-}
-export interface DeliveryOutcome {
-    ok: boolean;
-    /** Per-recipient replies (broadcast may have several). */
-    replies?: Array<{
-        memberId: string;
-        name: string;
-        reply: string;
-    }>;
-    error?: string;
-}
-export declare class TeamRegistry {
-    private readonly members;
-    register(member: TeamRegistryMember): void;
-    unregister(memberId: string): void;
-    /** Live roster (alive flag reflects the underlying process). */
-    list(): TeamRegistryListEntry[];
-    /**
-     * Resolve a send `to` token to concrete members.
-     * Accepts a member name ("coder"), a full member id ("team-x-coder"),
-     * or "*" for broadcast to all alive members.
-     * Returns [] when nothing matches (caller fails loud).
-     */
-    private resolveTargets;
-    /**
-     * Deliver a message to the resolved target(s) and collect replies.
-     * Fail-loud: no target → ok:false; any delivery error → surfaced.
-     */
-    deliver(to: string, message: string, fromId: string): Promise<DeliveryOutcome>;
-}

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

@@ -1,11 +0,0 @@
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-import type { AgentLogger } from "../../agent/types.js";
-import { type TeamToolServiceHost } from "./team-tool-service.js";
-import type { TeamRegistry } from "./team-registry.js";
-export interface TeamToolRegistrationDeps {
-    host: TeamToolServiceHost;
-    log: AgentLogger;
-    toolCatalog: ToolCatalog;
-    teamRegistry: TeamRegistry;
-}
-export declare function registerTeamTool({ host, log, toolCatalog, teamRegistry }: TeamToolRegistrationDeps): void;

package/dist/types/cli/core-tools/team-tool-service.d.ts

@@ -1,43 +0,0 @@
-import type { AgentLogger } from "../../agent/types.js";
-import type { BackgroundTaskManager } from "../../runtime/infra/background-tasks.js";
-import type { TeamToolDeps } from "../../skills/tools/team-tool.js";
-import type { TeamRegistry } from "./team-registry.js";
-export interface TeamToolService extends TeamToolDeps {
-    dispose(): void;
-}
-export interface TeamToolServiceHost {
-    readonly currentSessionId: string;
-    readonly verbose: boolean;
-    /**
-     * The leader's resolved LLM config, pushed to each spawned member as standing
-     * session config (session/set_config_option). Without it a standalone member
-     * (no llmrouter directory to hydrate a catalog from) cannot provision a
-     * provider, and its first reply turn fails with NO_PROVIDER. Returns null
-     * when the leader has no resolved provider yet.
-     */
-    getLlmConfig(): {
-        provider: string;
-        model: string;
-        apiKey: string;
-        baseUrl?: string;
-    } | null;
-    /** Lightweight memory INDEX injected into each member's system prompt (parent context). */
-    getMemoryIndex(): string | null;
-    /**
-     * Unified background-task registry. Team members register here as `team_member`
-     * tasks so the `task` tool's list/output/cancel reach them. Null when unbound.
-     */
-    getBackgroundTasks(): BackgroundTaskManager | null;
-    sendNotification(method: string, params: Record<string, unknown>): void;
-    emitAgentStatus(agentId: string, state: string, extra?: {
-        missedBeats?: number;
-        lastActivityAt?: number;
-        usage?: {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-        };
-    }): void;
-    handleMcpToolCall(memberId: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
-}
-export declare function createTeamToolService(host: TeamToolServiceHost, log: AgentLogger, registry: TeamRegistry): TeamToolService;

package/dist/types/cli/skill-meta-subturn-service.d.ts

@@ -1,26 +0,0 @@
-import type { TurnEvent, TurnRequest } from "../agent/types.js";
-import type { HookRegistry } from "../contracts/hooks.js";
-import type { ToolCatalog } from "../runtime/ports/index.js";
-import { type CommunitySignalReporter } from "../runtime/community/community-signal-reporter.js";
-import { type SkillSandbox } from "../runtime/sandbox/skill-sandbox.js";
-import { type SkillLifecycleRecord } from "../skills/skill-system/skill-lifecycle.js";
-export interface SkillSubturnAgent {
-    run(request: TurnRequest, signal?: AbortSignal): AsyncGenerator<TurnEvent>;
-}
-export interface SkillSubturnHost {
-    getAgent(): SkillSubturnAgent | null;
-    getCurrentSessionId(): string;
-    getCurrentHooks(): HookRegistry | null;
-}
-export interface ExecuteSkillSubturnParams {
-    host: SkillSubturnHost;
-    toolCatalog: ToolCatalog;
-    skillName: string;
-    skillContent: string;
-    userArgs?: string;
-    signal?: AbortSignal;
-    communitySignalReporter?: CommunitySignalReporter | null;
-    skillSandbox?: SkillSandbox | null;
-}
-export declare function executeSkillSubturn(params: ExecuteSkillSubturnParams): Promise<string>;
-export declare function resolveSkillSubagentTypeForLifecycle(skillName: string, record: SkillLifecycleRecord | undefined): string;

package/dist/types/runtime/hooks/skill-recall-hooks.d.ts

@@ -1,37 +0,0 @@
-import type { HookRegistry } from "../../contracts/hooks.js";
-import type { CommunityDiscoveryCoordinator } from "../community/community-discovery-coordinator.js";
-export declare const SKILL_RECALL_CONFIG: {
-    readonly MAX_RECALLED_SKILLS: 3;
-    readonly MAX_SKILL_CONTENT_CHARS: 800;
-    readonly CACHE_TTL_MS: number;
-};
-/**
- * Detect whether user message contains retrospective/cross-reference semantics
- * OR similar-task patterns that could benefit from existing skills.
- * Returns extracted keywords for skill matching if triggered, or null.
- */
-export declare function detectRetrospectiveTrigger(message: string): string[] | null;
-export interface SkillRecallHooksDeps {
-    /** Current project cwd (to exclude from cross-project search). */
-    currentCwd?: string;
-    /** Optional online community discovery coordinator. */
-    communityDiscovery?: CommunityDiscoveryCoordinator | null;
-    /** Logger. */
-    log: {
-        debug(msg: string): void;
-        warn(msg: string): void;
-    };
-}
-/**
- * Register the cross-project skill recall hook on `memory.before_recall`.
- * Runs at lower priority (60) than QMemory prefetch (50) so it supplements,
- * not replaces, the standard memory recall.
- *
- * When triggered, injects cross-project skill metadata into recalledMemories.
- */
-export declare function registerSkillRecallHooks(hooks: HookRegistry, deps: SkillRecallHooksDeps): () => void;
-/**
- * Invalidate the cross-project skill index cache.
- * Call when skills are created/deleted/promoted to refresh.
- */
-export declare function invalidateSkillRecallCache(): void;