qlogicagent 1.1.1 → 1.2.1

package/dist/types/runtime/session/session-state.d.ts

@@ -4,7 +4,6 @@
  * Unified state container for a single agent session:
  *   - Token usage / cost accumulation across turns
  *   - Session trust acceptance (per-session, non-persistent)
- *   - Background memory extraction trigger thresholds
  *   - Session-level settings
  *
  * This module is the qlogicagent equivalent of CC's:
@@ -39,15 +38,6 @@ export interface SessionUsageSnapshot {
 }
 /** @deprecated Use SessionUsageSnapshot. Kept for persistence compat. */
 export type SessionCostSnapshot = SessionUsageSnapshot;
-/** Thresholds for background memory extraction — CC sessionMemory.ts parity */
-export interface MemoryExtractionThresholds {
-    /** Token threshold before FIRST extraction (default 10000) */
-    initialTokenThreshold: number;
-    /** Token threshold between UPDATES (default 5000) */
-    updateTokenThreshold: number;
-    /** Tool call threshold (default 3) */
-    toolCallThreshold: number;
-}
 export declare class SessionState {
     readonly sessionId: string;
     private _trustAccepted;
@@ -56,13 +46,8 @@ export declare class SessionState {
     private _totalOutputTokens;
     private _turnCount;
     private _toolCallCount;
-    private _tokensSinceLastExtraction;
-    private _toolCallsSinceLastExtraction;
-    private _hasExtractedOnce;
     private _listeners;
-    /** Memory extraction thresholds — CC sessionMemory defaults */
-    readonly extractionThresholds: MemoryExtractionThresholds;
-    constructor(sessionId: string, thresholds?: Partial<MemoryExtractionThresholds>);
+    constructor(sessionId: string);
     get trustAccepted(): boolean;
     setTrustAccepted(accepted: boolean): void;
     get totalInputTokens(): number;
@@ -86,23 +71,10 @@ export declare class SessionState {
      * Tracks quantities only (calls, seconds, characters); pricing is Hub/Admin's job.
      */
     addMediaUsage(model: string, billingUnit: string, quantity: number): void;
-    /** Record a tool call (for extraction threshold tracking) */
+    /** Record a tool call */
     recordToolCall(): void;
     /** Increment turn count */
     recordTurnCompleted(): void;
-    /**
-     * Check whether background memory extraction should trigger.
-     * CC sessionMemory.ts shouldExtract() parity.
-     *
-     * Logic:
-     *   - Token threshold is ALWAYS required
-     *   - Tool call threshold is an additional gate
-     *   - Token threshold: initialTokenThreshold before first extraction,
-     *     updateTokenThreshold after
-     */
-    shouldExtractMemory(): boolean;
-    /** Mark that extraction was performed — reset counters */
-    markExtractionDone(): void;
     /**
      * Create a snapshot for persistence.
      * CC saveCurrentSessionCosts() parity.
@@ -123,4 +95,4 @@ export declare class SessionState {
 /**
  * Create a new session state instance.
  */
-export declare function createSessionState(sessionId: string, thresholds?: Partial<MemoryExtractionThresholds>): SessionState;
+export declare function createSessionState(sessionId: string): SessionState;

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

@@ -6,8 +6,6 @@ export { MemoryStore, MEMORY_ENTRY_DELIMITER, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT
 export type { MemoryStoreTarget, MemoryStoreResult, MemoryStoreOptions, MemoryStoreSerialized, } from "./memory/memory-store.js";
 export { createQMemoryAdapter } from "./memory/qmemory-adapter.js";
 export type { QMemoryAdapterConfig, QMemoryHealthStatus, ExtractedMemoryItem } from "./memory/qmemory-adapter.js";
-export { createMemoryExtractor } from "./memory/memory-extractor.js";
-export type { ExtractedMemory, ProfileUpdate, ExtractionResult, ExtractionCompleteFn, MemoryExtractorOptions, } from "./memory/memory-extractor.js";
 export { THINK_TOOL_NAME, THINK_TOOL_SCHEMA, createThinkTool } from "./think-tool.js";
 export type { ThinkToolParams } from "./think-tool.js";
 export { TODO_TOOL_NAME, TODO_TOOL_SCHEMA, TODO_ACTIONS, createTodoTool } from "./todo-tool.js";
@@ -50,12 +48,8 @@ export { BRIEF_TOOL_NAME, BRIEF_TOOL_SCHEMA, createBriefTool } from "./tools/bri
 export type { BriefToolParams, BriefToolDeps, BriefMessageStatus, BriefAttachment, BriefDeliveryResult, BriefModeConfig, } from "./tools/brief-tool.js";
 export { TOOL_SEARCH_TOOL_NAME, TOOL_SEARCH_TOOL_SCHEMA, createToolSearchTool } from "./tools/tool-search-tool.js";
 export type { ToolSearchToolParams, ToolSearchToolDeps, DeferredToolInfo, ToolSearchOutput } from "./tools/tool-search-tool.js";
-export { SKILL_LIST_TOOL_NAME, SKILL_LIST_TOOL_SCHEMA, createSkillListTool } from "./tools/skill-list-tool.js";
-export type { SkillListToolParams, SkillListToolDeps, SkillListItem, SkillListOutput } from "./tools/skill-list-tool.js";
-export { SKILL_VIEW_TOOL_NAME, SKILL_VIEW_TOOL_SCHEMA, createSkillViewTool } from "./tools/skill-view-tool.js";
-export type { SkillViewToolParams, SkillViewToolDeps, SkillViewOutput } from "./tools/skill-view-tool.js";
-export { SKILL_MANAGE_TOOL_NAME, SKILL_MANAGE_TOOL_SCHEMA, createSkillManageTool } from "./tools/skill-manage-tool.js";
-export type { SkillManageToolParams, SkillManageToolDeps, SkillManageResult, SkillManageAction } from "./tools/skill-manage-tool.js";
+export { SKILL_TOOL_NAME, SKILL_TOOL_SCHEMA, createSkillMetaTool } from "./tools/skill-tool.js";
+export type { SkillAction, SkillToolParams, SkillToolDeps, SkillListItem, SkillListOutput, SkillViewOutput, SkillManageResult } from "./tools/skill-tool.js";
 export { PATCH_TOOL_NAME, PATCH_TOOL_SCHEMA, createPatchTool, fuzzyFind } from "./tools/patch-tool.js";
 export type { PatchToolParams, PatchToolDeps, PatchResult, MatchStrategy, MatchResult } from "./tools/patch-tool.js";
 export { AGENT_TOOL_NAME, AGENT_TOOL_SCHEMA, createAgentTool } from "./tools/agent-tool.js";
@@ -103,8 +97,6 @@ export { scanSource, scanSkillDirectory, hasCriticalFindings, isScannable, } fro
 export type { SkillGuardDeps } from "./skill-system/skill-guard.js";
 export { installSkill, uninstallSkill, createEmptyLockfile, } from "./skill-system/skill-source.js";
 export type { TrustLevel, ScanVerdict, SkillSourceDescriptor, SkillFetchResult, SkillFetchDeps, SkillStorageDeps, SkillLockEntry, SkillLockfile, SkillInstallResult, } from "./skill-system/skill-source.js";
-export { SKILL_TOOL_NAME, SKILL_INVOKE_SCHEMA, createSkillTool } from "./tools/skill-invoke-tool.js";
-export type { SkillInvokeParams, SkillToolDeps } from "./tools/skill-invoke-tool.js";
 export { McpStdioClient } from "./mcp/mcp-stdio-client.js";
 export { McpManager, parseMcpConfig } from "./mcp/mcp-manager.js";
 export type { McpServerEntry, McpManagerConfig } from "./mcp/mcp-manager.js";

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

@@ -0,0 +1,101 @@
+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";
+export interface SkillToolParams {
+    action: SkillAction;
+    name?: string;
+    args?: string;
+    category?: string;
+    content?: string;
+    filePath?: string;
+    fileContent?: string;
+    oldString?: string;
+    newString?: string;
+}
+export declare const SKILL_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly action: {
+            readonly type: "string";
+            readonly enum: readonly ["invoke", "list", "view", "create", "edit", "patch", "delete"];
+            readonly description: string;
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Skill name (required for invoke/view/create/edit/patch/delete).";
+        };
+        readonly args: {
+            readonly type: "string";
+            readonly description: "Arguments or context to pass when invoking a skill.";
+        };
+        readonly category: {
+            readonly type: "string";
+            readonly description: "Filter skills by category (for 'list' action).";
+        };
+        readonly content: {
+            readonly type: "string";
+            readonly description: "Full SKILL.md content for create/edit actions.";
+        };
+        readonly filePath: {
+            readonly type: "string";
+            readonly description: "View a specific file within the skill (for 'view' action).";
+        };
+        readonly fileContent: {
+            readonly type: "string";
+            readonly description: "Content for writing supporting files.";
+        };
+        readonly oldString: {
+            readonly type: "string";
+            readonly description: "Text to find for patch action.";
+        };
+        readonly newString: {
+            readonly type: "string";
+            readonly description: "Replacement text for patch action.";
+        };
+    };
+    readonly required: readonly ["action"];
+};
+export interface SkillListItem {
+    name: string;
+    description: string;
+    version?: string;
+    category?: string;
+}
+export interface SkillListOutput {
+    skills: SkillListItem[];
+    categories: string[];
+}
+export interface SkillViewOutput {
+    name: string;
+    content: string;
+    referenceFiles?: string[];
+}
+export interface SkillManageResult {
+    success: boolean;
+    message: string;
+    path?: string;
+}
+export interface SkillToolDeps {
+    /** List all available skills (Layer 0 metadata). */
+    listSkills(): WorkspaceSkill[];
+    /** List skills with full detail (for list action). */
+    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>;
+    /** Manage skill (create/edit/patch/delete). */
+    manageSkill(params: {
+        action: string;
+        name: string;
+        content?: string;
+        filePath?: string;
+        fileContent?: string;
+        oldString?: string;
+        newString?: string;
+    }): Promise<SkillManageResult>;
+}
+export declare function createSkillMetaTool(deps: SkillToolDeps): PortableTool<SkillToolParams>;

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

@@ -5,6 +5,14 @@ export interface TeamMember {
     name: string;
     role: string;
     tools?: string[];
+    /** Working directory for this member (worktree path or inherited cwd). */
+    cwd?: string;
+    /** Git worktree path if auto-provisioned (CC TeamMember.worktreePath parity). */
+    worktreePath?: string;
+    /** Git worktree branch name (for cleanup). */
+    worktreeBranch?: string;
+    /** Whether the member is currently active. */
+    isActive?: boolean;
 }
 export interface TeamToolParams {
     action: TeamAction;
@@ -84,6 +92,20 @@ export interface TeamToolDeps {
     }): Promise<TeamResult>;
     deleteTeam(teamName: string): Promise<TeamResult>;
     listTeams(): Promise<TeamResult>;
-    getTeamStatus(teamName: string): Promise<TeamResult>;
+    getTeamStatus(teamName: string): Promise<TeamResult & {
+        memberProgress?: Record<string, {
+            mediaProgress?: {
+                taskId: string;
+                mediaType: string;
+                percent: number;
+                status: string;
+                provider?: string;
+                updatedAt: number;
+            };
+            lastToolCall?: string;
+            idleFor?: number;
+            runningFor?: number;
+        }>;
+    }>;
 }
 export declare function createTeamTool(deps: TeamToolDeps): PortableTool<TeamToolParams>;

package/package.json

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

package/dist/types/runtime/session/session-memory.d.ts

@@ -1,90 +0,0 @@
-/**
- * Session Memory — CC SessionMemory background extraction parity.
- *
- * Automatically extracts key insights from the conversation and saves
- * them to session memory files. Runs as a forked sub-agent with restricted
- * tool access after each turn when extraction thresholds are met.
- *
- * CC reference:
- *   - src/services/SessionMemory/sessionMemory.ts
- *   - src/services/SessionMemory/extractMemories.ts
- *
- * Extraction process:
- *   1. Check thresholds (tokens + tool calls since last extraction)
- *   2. Fork a sub-agent with restricted tools (read-only + memory write)
- *   3. Sub-agent reviews conversation, extracts key facts/decisions
- *   4. Sub-agent writes to session-memory.md file
- *   5. Reset threshold counters
- *
- * Tool restrictions for extractor:
- *   ✅ read, search, grep, glob (read-only fs)
- *   ✅ memory_write (to session-memory path only)
- *   ❌ Everything else (no file edits, no bash, no network)
- */
-import type { ChatMessage, ToolDefinition, ToolInvoker, AgentLogger, HookRegistry } from "../../agent/types.js";
-import type { LLMTransport } from "../../llm/transport.js";
-import type { SessionState } from "./session-state.js";
-/** Tool permission check function (mirrors execution/forked-agent CanUseToolFn). */
-export type CanUseToolFn = (toolName: string, input: Record<string, unknown>) => {
-    allowed: true;
-} | {
-    allowed: false;
-    reason: string;
-};
-/** Forked agent runner signature (injected by CLI layer). */
-export type ForkedAgentRunner = (params: {
-    promptMessages: ChatMessage[];
-    systemPrompt?: string;
-    tools: ToolDefinition[];
-    canUseTool?: CanUseToolFn;
-    transport: LLMTransport;
-    toolInvoker: ToolInvoker;
-    apiKey: string;
-    model: string;
-    log: AgentLogger;
-    hooks?: HookRegistry;
-    forkLabel: string;
-    maxTurns?: number;
-    parentSignal?: AbortSignal;
-    skipTranscript?: boolean;
-}) => Promise<{
-    ok: boolean;
-    content?: string;
-    error?: string;
-    durationMs: number;
-    totalUsage: {
-        prompt: number;
-        completion: number;
-    };
-}>;
-export interface SessionMemoryDeps {
-    /** Session state (for threshold tracking) */
-    sessionState: SessionState;
-    /** LLM transport for the extractor agent */
-    transport: LLMTransport;
-    /** Tool invoker */
-    toolInvoker: ToolInvoker;
-    /** Available tools (will be filtered for extraction) */
-    tools: ToolDefinition[];
-    /** API key */
-    apiKey: string;
-    /** Model for extraction (can use a cheaper/faster model) */
-    model: string;
-    /** Logger */
-    log: AgentLogger;
-    /** Hook registry */
-    hooks?: HookRegistry;
-    /** Path where session memory should be written */
-    memoryFilePath: string;
-    /** Parent abort signal */
-    parentSignal?: AbortSignal;
-    /** Forked agent runner (injected by CLI layer, decoupled from execution/) */
-    runForkedAgent: ForkedAgentRunner;
-}
-/**
- * Check if memory extraction should run and execute if thresholds are met.
- *
- * Call this at the end of each turn (after turn.completed hook).
- * It's a no-op if thresholds aren't met.
- */
-export declare function maybeExtractSessionMemory(deps: SessionMemoryDeps, conversationMessages: ChatMessage[]): Promise<boolean>;

package/dist/types/skills/memory/memory-extractor.d.ts

@@ -1,64 +0,0 @@
-export interface ExtractedMemory {
-    text: string;
-    category: string;
-    importance: number;
-    speaker: string;
-    event_date?: string;
-    tags?: string[];
-}
-export interface ProfileUpdate {
-    category: string;
-    key: string;
-    value: string;
-    confidence: number;
-}
-export interface ExtractionResult {
-    memories: ExtractedMemory[];
-    profileUpdates: ProfileUpdate[];
-}
-/**
- * Generic OpenAI-compatible chat completion function.
- * Consumer provides the actual HTTP transport (e.g. admin/new-api fetch).
- */
-export type ExtractionCompleteFn = (params: {
-    model: string;
-    messages: Array<{
-        role: string;
-        content: string;
-    }>;
-    tools: unknown[];
-    tool_choice: unknown;
-    temperature?: number;
-    max_tokens?: number;
-}) => Promise<{
-    choices?: Array<{
-        message?: {
-            tool_calls?: Array<{
-                function?: {
-                    name?: string;
-                    arguments?: string;
-                };
-            }>;
-            content?: string;
-        };
-    }>;
-}>;
-export interface MemoryExtractorOptions {
-    /** Model to use for extraction (default: "deepseek-v4-flash"). */
-    model?: string;
-    /** Timeout in ms for the LLM call (default: 30_000). */
-    timeoutMs?: number;
-}
-/**
- * Create a memory extractor backed by an OpenAI-compatible LLM endpoint.
- *
- * The `complete` function is injected by the consumer so that
- * skills layer stays transport-agnostic (no admin/new-api dependency).
- */
-export declare function createMemoryExtractor(complete: ExtractionCompleteFn, options?: MemoryExtractorOptions): {
-    /**
-     * Extract structured memories from a conversation fragment.
-     * Returns empty result if text is too short or LLM call fails.
-     */
-    extract(conversationText: string): Promise<ExtractionResult>;
-};