qlogicagent 0.5.3 → 0.6.0

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

@@ -1,4 +1,3 @@
-import type { ToolRegistry } from "../tool-registry.js";
 /** MCP resource entry from resources/list */
 export interface McpResourceEntry {
     uri: string;
@@ -42,7 +41,7 @@ export interface McpManagerConfig {
 }
 export declare class McpManager {
     private clients;
-    private registry;
+    private injected;
     private log;
     constructor(config: McpManagerConfig);
     /**
@@ -50,9 +49,9 @@ export declare class McpManager {
      */
     connectAll(): Promise<void>;
     /**
-     * Register all MCP tools into the given ToolRegistry.
+     * Register all MCP tools into the centralized tool pool.
      */
-    injectTools(registry: ToolRegistry): void;
+    injectTools(): void;
     /**
      * Get names of all connected servers.
      */

package/dist/types/skills/mcp/mcp-stdio-client.d.ts

@@ -64,7 +64,7 @@ export declare class McpStdioClient {
         blob?: string;
     }>>;
     /**
-     * Convert MCP tools to PortableTool instances for ToolRegistry.
+     * Convert MCP tools to PortableTool instances for the tool pool.
      * Tool names are prefixed: mcp__{serverName}__{toolName}
      */
     toPortableTools(): PortableTool[];

package/dist/types/skills/{memory-store.d.ts → memory/memory-store.d.ts}

@@ -14,6 +14,8 @@ export interface MemoryStoreResult {
 export interface MemoryStoreOptions {
     memoryCharLimit?: number;
     userCharLimit?: number;
+    /** When true, mutations automatically persist to ~/.qlogicagent/memory.json */
+    persistToDisk?: boolean;
 }
 export interface MemoryStoreSerialized {
     memory: string;
@@ -24,8 +26,10 @@ export declare class MemoryStore {
     private userEntries;
     private frozenSnapshot;
     private snapshotFrozen;
+    private saveTimer;
     private readonly memoryCharLimit;
     private readonly userCharLimit;
+    private readonly persistToDisk;
     constructor(options?: MemoryStoreOptions);
     /**
      * Load from serialized form (e.g. from PG or filesystem).
@@ -36,6 +40,22 @@ export declare class MemoryStore {
      * Serialize current live state for persistence.
      */
     serialize(): MemoryStoreSerialized;
+    /**
+     * Load from disk (~/.qlogicagent/memory.json). No-op if file doesn't exist.
+     * Call this at startup when persistToDisk is enabled.
+     */
+    loadFromDisk(): Promise<void>;
+    /**
+     * Synchronous variant for use in sync constructors / init paths.
+     */
+    loadFromDiskSync(): void;
+    /**
+     * Schedule a debounced save to disk (500ms). Multiple rapid mutations
+     * coalesce into a single disk write.
+     */
+    private scheduleSave;
+    /** Flush any pending save immediately. Call before shutdown. */
+    flush(): Promise<void>;
     /**
      * Freeze current entries for system prompt injection.
      * Call once at session start. After freezing, mutations update

package/dist/types/skills/{memory-tool.d.ts → memory/memory-tool.d.ts}

@@ -1,5 +1,13 @@
 import type { MemoryProvider, MemorySearchResult } from "qlogicagent-runtime-contracts";
 import type { MemoryStore, MemoryStoreTarget } from "./memory-store.js";
+export interface MediaPreferencesSummary {
+    imageStyle?: string;
+    videoStyle?: string;
+    musicGenre?: string;
+    musicMood?: string;
+    primaryPurpose?: string;
+    colorPreference?: string;
+}
 export declare const MEMORY_TOOL_NAME: "memory";
 export declare const MEMORY_TOOL_MAX_CONTENT_LENGTH = 2000;
 export declare const MEMORY_TOOL_ACTIONS: readonly ["add", "replace", "remove", "search"];
@@ -29,6 +37,11 @@ export declare const MEMORY_TOOL_SCHEMA: {
             readonly type: "string";
             readonly description: "Required for 'search'. Natural language query to find relevant memories.";
         };
+        readonly category: {
+            readonly type: "string";
+            readonly enum: readonly ["profile", "facts", "media", "projects"];
+            readonly description: string;
+        };
     };
     readonly required: readonly ["action"];
 };
@@ -41,6 +54,7 @@ export interface MemoryToolParams {
     content?: string;
     old_text?: string;
     query?: string;
+    category?: "profile" | "facts" | "media" | "projects";
 }
 export interface MemoryToolResult {
     ok: boolean;
@@ -63,5 +77,11 @@ export interface MemoryToolExecutorDeps {
     store?: MemoryStore;
     userId: string;
     sessionId?: string;
+    /** Query recalled facts/memories by natural language. */
+    queryGraph?: (query: string, userId: string) => string[];
+    /** Retrieve user profile summary. */
+    getProfileSummary?: (userId: string) => string | null;
+    /** Retrieve media preferences. */
+    getMediaPreferences?: (userId: string) => MediaPreferencesSummary | null;
 }
 export declare function executeMemoryTool(params: MemoryToolParams, deps: MemoryToolExecutorDeps): Promise<MemoryToolResult>;

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

@@ -3,7 +3,7 @@ import type { ToolDefinition } from "../../agent/types.js";
 import { PermissionRuleEngine } from "./rule-engine.js";
 import type { PermissionUpdate, ApprovalRequest, ApprovalResponse } from "./types.js";
 import { type ClassifierLLMCall } from "./permission-classifier.js";
-import type { PermissionRole } from "../../orchestration/task-types.js";
+import type { PermissionRole } from "../../orchestration/subagent/task-types.js";
 export interface PermissionCheckerDeps {
     ruleEngine: PermissionRuleEngine;
     hookRegistry: HookRegistry;

package/dist/types/skills/permissions/settings-watcher.d.ts

@@ -5,7 +5,7 @@
  * when it changes on disk. This allows users to adjust permission rules
  * without restarting the agent session.
  *
- * Settings file location: `.openclaw/settings.json` in the project root
+ * Settings file location: `.qlogicagent/settings.json` in the project root
  *
  * Watched fields:
  *   - permissionMode: PermissionMode
@@ -24,7 +24,7 @@ export interface SettingsFile {
     defaultBehavior?: PermissionBehavior;
 }
 export interface SettingsWatcherDeps {
-    /** Project root directory (where .openclaw/ lives) */
+    /** Project root directory (where .qlogicagent/ lives) */
     projectRoot: string;
     /** Permission rule engine to update on changes */
     ruleEngine: PermissionRuleEngine;

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

@@ -1,6 +1,6 @@
 import type { PortableTool } from "../portable-tool.js";
 import type { HookPoint, HookHandler } from "../../contracts/hooks.js";
-import type { WorkspaceSkill } from "../skill-types.js";
+import type { WorkspaceSkill } from "../skill-system/skill-types.js";
 export type PluginHookPhase = "preToolUse" | "postToolUse" | "onTurnStart" | "onTurnEnd" | "onSessionEnd";
 /** Map plugin hook phases to internal HookPoint names */
 export declare const PLUGIN_HOOK_MAP: Record<PluginHookPhase, HookPoint>;

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

@@ -1,12 +1,9 @@
-import type { ToolRegistry } from "../tool-registry.js";
 import type { HookRegistry } from "../../contracts/hooks.js";
-import type { WorkspaceSkill } from "../skill-types.js";
+import type { WorkspaceSkill } from "../skill-system/skill-types.js";
 import { type LoadedPlugin } from "./plugin-api.js";
 export interface PluginLoaderConfig {
     /** Directories to scan for plugins (order = priority) */
     pluginDirs: string[];
-    /** ToolRegistry to inject plugin tools into */
-    toolRegistry: ToolRegistry;
     /** HookRegistry to wire plugin hooks into */
     hookRegistry: HookRegistry;
     /** Logger */

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

@@ -51,7 +51,7 @@ export declare function loadCachedPlugins(): string[];
 export declare function installMarketplacePlugins(config: MarketplaceConfig, log: MarketplaceLogger): Promise<string[]>;
 /**
  * Get the marketplace config from user settings.
- * Reads ~/.openclaw/marketplace.json
+ * Reads ~/.qlogicagent/marketplace.json
  */
 export declare function loadMarketplaceConfig(): MarketplaceConfig | null;
 /**

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

@@ -23,7 +23,7 @@ export interface PortableToolResult {
  * @typeParam TParams The expected parameter shape (for TypeScript consumers).
  */
 export interface PortableTool<TParams = Record<string, unknown>> {
-    /** Unique tool name (e.g. "think", "todo", "memory_query"). */
+    /** Unique tool name (e.g. "think", "todo", "memory"). */
     name: string;
     /** Human-readable label. */
     label: string;
@@ -49,6 +49,27 @@ export interface PortableTool<TParams = Record<string, unknown>> {
      * Read-only tools can skip confirmation prompts in strict permission modes.
      */
     isReadOnly?: boolean;
+    /**
+     * Whether the tool is currently available.
+     * CC parity: tools that return false are excluded from getTools().
+     * Default: true (always enabled).
+     */
+    isEnabled?: () => boolean;
+    /**
+     * Whether the tool performs destructive operations (delete, overwrite, etc.).
+     * CC parity: Tool.isDestructive field.
+     * Used by permission system to require confirmation.
+     */
+    isDestructive?: boolean;
+    /**
+     * Tool-specific permission check before execution.
+     * CC parity: Tool.checkPermissions — returns allow/deny with reason.
+     * Default (via buildTool): always allow, deferring to general permission system.
+     */
+    checkPermissions?: (params: TParams) => {
+        behavior: "allow" | "deny";
+        reason?: string;
+    };
     /**
      * Brief keyword hint for tool_search to match against
      * (e.g. "return the final response as structured JSON").
@@ -69,3 +90,15 @@ export interface PortableTool<TParams = Record<string, unknown>> {
      */
     execute(toolCallId: string, params: TParams, signal?: AbortSignal): Promise<PortableToolResult>;
 }
+/**
+ * Build a complete PortableTool from a partial definition, filling safe defaults.
+ * CC parity: buildTool() factory in Tool.ts.
+ *
+ * Defaults (fail-closed where it matters):
+ * - isEnabled → true
+ * - isConcurrencySafe → false
+ * - isReadOnly → false
+ * - isDestructive → false
+ * - checkPermissions → { behavior: "allow" } (defer to general permission system)
+ */
+export declare function buildTool<TParams = Record<string, unknown>>(partial: PortableTool<TParams>): PortableTool<TParams>;

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

@@ -1,63 +1,72 @@
-import type { TodoItem } from "../contracts/todo.js";
+import type { TodoItemStatus } from "../contracts/todo.js";
 import type { PortableTool } from "./portable-tool.js";
 export declare const TODO_TOOL_NAME: "todo";
+export declare const TODO_ACTIONS: readonly ["create", "update", "delete", "list"];
+export type TodoAction = (typeof TODO_ACTIONS)[number];
 export interface TodoToolParams {
-    todoList: TodoItem[];
+    action: TodoAction;
+    id?: number;
+    title?: string;
+    description?: string;
+    status?: TodoItemStatus;
+    owner?: string;
+    addBlocks?: number[];
+    addBlockedBy?: number[];
 }
 export declare const TODO_TOOL_SCHEMA: {
     readonly type: "object";
     readonly properties: {
-        readonly todoList: {
-            readonly type: "array";
+        readonly action: {
+            readonly type: "string";
+            readonly enum: readonly ["create", "update", "delete", "list"];
             readonly description: string;
+        };
+        readonly id: {
+            readonly type: "number";
+            readonly description: "[update|delete] Task id to operate on.";
+        };
+        readonly title: {
+            readonly type: "string";
+            readonly description: "[create|update] Task title (3-7 words).";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "[create|update] Detailed task description.";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["not-started", "in-progress", "completed"];
+            readonly description: "[create|update] Task status. create defaults to not-started.";
+        };
+        readonly owner: {
+            readonly type: "string";
+            readonly description: "[create|update] Owner agent/subagent identifier.";
+        };
+        readonly addBlocks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+            };
+            readonly description: "[update] Task IDs that this task should block.";
+        };
+        readonly addBlockedBy: {
+            readonly type: "array";
             readonly items: {
-                readonly type: "object";
-                readonly properties: {
-                    readonly id: {
-                        readonly type: "number";
-                        readonly description: "Unique numeric id (sequential from 1).";
-                    };
-                    readonly title: {
-                        readonly type: "string";
-                        readonly description: "Concise action-oriented label (3-7 words). Displayed in UI.";
-                    };
-                    readonly status: {
-                        readonly type: "string";
-                        readonly enum: readonly ["not-started", "in-progress", "completed"];
-                        readonly description: "not-started | in-progress (max 1) | completed";
-                    };
-                };
-                readonly required: readonly ["id", "title", "status"];
+                readonly type: "number";
             };
+            readonly description: "[update] Task IDs that should block this task.";
         };
     };
-    readonly required: readonly ["todoList"];
+    readonly required: readonly ["action"];
 };
 /**
- * Configuration for todo tool behavior (CC-aligned features).
+ * Configuration for todo tool behavior.
  */
 export interface TodoToolOptions {
-    /**
-     * Unique agent/session identifier for per-agent todo isolation.
-     * When provided, different agents have independent todo lists.
-     */
+    /** Unique agent/session identifier for per-agent todo isolation. */
     agentId?: string;
-    /**
-     * Whether verification nudge is enabled.
-     * When all items are completed (≥3 items, none matching /verif/i),
-     * the tool signals that a verification sub-agent should be spawned.
-     */
-    enableVerificationNudge?: boolean;
-    /**
-     * Whether to auto-clear the list when all items are completed.
-     * Matches CC behavior: allDone → newTodos = [].
-     */
-    autoClearOnComplete?: boolean;
 }
 /**
- * Create a stateful todo tool instance.
- *
- * Each call returns a tool with its own session-local list.
- * Multiple instances can exist for different sessions/agents.
+ * Create a stateful todo tool instance (V2 — incremental CRUD).
  */
 export declare function createTodoTool(options?: TodoToolOptions): PortableTool<TodoToolParams>;

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

@@ -21,83 +21,45 @@ export interface InstructionsToolDeps {
     /** Remove an instruction file. Returns true if deleted. */
     remove(projectId: string, filename: string): boolean;
 }
-export declare const INSTRUCTIONS_LIST_TOOL_NAME: "instructions_list";
-export interface InstructionsListParams {
+export declare const INSTRUCTIONS_TOOL_NAME: "instructions";
+export type InstructionsAction = "list" | "read" | "write" | "edit" | "delete";
+export interface InstructionsToolParams {
+    action: InstructionsAction;
     project_id: string;
+    filename?: string;
+    content?: string;
+    old_text?: string;
+    new_text?: string;
 }
-export declare const INSTRUCTIONS_LIST_SCHEMA: {
+export declare const INSTRUCTIONS_TOOL_SCHEMA: {
     readonly type: "object";
     readonly properties: {
-        readonly project_id: {
+        readonly action: {
             readonly type: "string";
-            readonly description: "Project ID to list instructions for. Use \"default\" for the default project.";
+            readonly enum: readonly ["list", "read", "write", "edit", "delete"];
+            readonly description: "Operation: list all files, read a file, write (create/overwrite), edit (partial replace), or delete a file.";
         };
-    };
-    readonly required: readonly ["project_id"];
-};
-export declare function createInstructionsListTool(deps: InstructionsToolDeps): PortableTool<InstructionsListParams>;
-export declare const INSTRUCTIONS_READ_TOOL_NAME: "instructions_read";
-export interface InstructionsReadParams {
-    project_id: string;
-    filename: string;
-}
-export declare const INSTRUCTIONS_READ_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
         readonly project_id: {
             readonly type: "string";
             readonly description: "Project ID. Use \"default\" for the default project.";
         };
         readonly filename: {
             readonly type: "string";
-            readonly description: "Instruction file name (e.g. \"code-style.md\"). Supports sub-paths like \"testing/unit-test.md\".";
-        };
-    };
-    readonly required: readonly ["project_id", "filename"];
-};
-export declare function createInstructionsReadTool(deps: InstructionsToolDeps): PortableTool<InstructionsReadParams>;
-export declare const INSTRUCTIONS_WRITE_TOOL_NAME: "instructions_write";
-export interface InstructionsWriteParams {
-    project_id: string;
-    filename: string;
-    content: string;
-}
-export declare const INSTRUCTIONS_WRITE_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly project_id: {
-            readonly type: "string";
-            readonly description: "Project ID. Use \"default\" for the default project.";
-        };
-        readonly filename: {
-            readonly type: "string";
-            readonly description: "Instruction file name ending in .md (e.g. \"code-style.md\"). Sub-paths like \"testing/unit-test.md\" are supported.";
+            readonly description: "Instruction file name ending in .md (e.g. \"code-style.md\"). Required for read/write/delete. Sub-paths like \"testing/unit-test.md\" are supported.";
         };
         readonly content: {
             readonly type: "string";
-            readonly description: "Markdown content for the instruction file.";
+            readonly description: "Markdown content for the instruction file. Required for write action.";
         };
-    };
-    readonly required: readonly ["project_id", "filename", "content"];
-};
-export declare function createInstructionsWriteTool(deps: InstructionsToolDeps): PortableTool<InstructionsWriteParams>;
-export declare const INSTRUCTIONS_DELETE_TOOL_NAME: "instructions_delete";
-export interface InstructionsDeleteParams {
-    project_id: string;
-    filename: string;
-}
-export declare const INSTRUCTIONS_DELETE_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly project_id: {
+        readonly old_text: {
             readonly type: "string";
-            readonly description: "Project ID. Use \"default\" for the default project.";
+            readonly description: "Required for edit action: the exact existing text to find and replace (must appear exactly once).";
         };
-        readonly filename: {
+        readonly new_text: {
             readonly type: "string";
-            readonly description: "Instruction file name to delete (e.g. \"code-style.md\").";
+            readonly description: "Required for edit action: the replacement text.";
         };
     };
-    readonly required: readonly ["project_id", "filename"];
+    readonly required: readonly ["action", "project_id"];
 };
-export declare function createInstructionsDeleteTool(deps: InstructionsToolDeps): PortableTool<InstructionsDeleteParams>;
+export declare function createInstructionsTool(deps: InstructionsToolDeps): PortableTool<InstructionsToolParams>;

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

@@ -1,5 +1,5 @@
 import type { PortableTool } from "../portable-tool.js";
-import type { WorkspaceSkill } from "../skill-types.js";
+import type { WorkspaceSkill } from "../skill-system/skill-types.js";
 export declare const SKILL_TOOL_NAME: "skill_invoke";
 export interface SkillInvokeParams {
     skill: string;
@@ -35,7 +35,7 @@ export interface SkillToolDeps {
      * Execute the skill instructions as a sub-turn.
      * The implementation should:
      *   1. Build system prompt from SKILL.md content
-     *   2. Run a sub-turn (sidechain) with skill instructions
+     *   2. Run a sub-turn (fork) with skill instructions
      *   3. Return the sub-turn's final response
      *
      * If not provided, the skill content is returned directly

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

@@ -0,0 +1,65 @@
+/**
+ * Tool Registry — CC-aligned getAllBaseTools() pattern.
+ *
+ * CC reference: claude-code-haha/src/tools.ts
+ *
+ * This is the SINGLE SOURCE OF TRUTH for all available tools.
+ * Tools are returned as a flat array from getAllBaseTools().
+ * Filtering/gating happens via getTools() using deny rules.
+ *
+ * Factory functions (createXxxTool) are kept because qlogicagent
+ * tools receive deps at creation time (vs CC context at call time).
+ * The registration pattern is aligned: pure function returns array.
+ */
+import type { PortableTool } from "./portable-tool.js";
+import type { ToolDefinition } from "../agent/types.js";
+import { AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, filterToolsForAgent } from "../agent/tool-access.js";
+export { AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, filterToolsForAgent };
+/**
+ * Register tools into the internal pool. Called by initToolDeps().
+ */
+export declare function setToolPool(tools: PortableTool[]): void;
+/**
+ * Add a single tool to the pool (for dynamic tools like MCP, plugins).
+ */
+export declare function addTool(tool: PortableTool<any>): void;
+/**
+ * Add multiple tools to the pool at once.
+ */
+export declare function addTools(tools: PortableTool<any>[]): void;
+/**
+ * Remove a tool by name. Returns true if it existed.
+ */
+export declare function removeTool(name: string): boolean;
+/**
+ * Find a tool by name.
+ */
+export declare function findTool(name: string): PortableTool | undefined;
+/**
+ * Check if a tool exists.
+ */
+export declare function hasTool(name: string): boolean;
+/**
+ * Get all tool names.
+ */
+export declare function getToolNames(): string[];
+/**
+ * Get the number of registered tools.
+ */
+export declare function getToolCount(): number;
+/**
+ * Execute a tool by name.
+ */
+export declare function executeTool(name: string, toolCallId: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<import("./portable-tool.js").PortableToolResult>;
+/**
+ * CC: getTools() — return all enabled tools.
+ * Filters the pool by isEnabled() gate; disabled tools are invisible to callers.
+ * CC reference: claude-code-haha/src/tools.ts getTools()
+ */
+export declare function getTools(): PortableTool[];
+/**
+ * Generate ToolDefinition[] manifest for LLM tool_use.
+ * Filters by isEnabled() — disabled tools never reach the model.
+ * CC: getTools() + manifest generation combined.
+ */
+export declare function getToolManifest(includeDeferred?: boolean): ToolDefinition[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",
@@ -32,7 +32,7 @@
     "dev": "tsx watch src/index.ts",
     "build": "node scripts/build.mjs",
     "build:tsc": "tsc --noCheck",
-    "start": "node dist/cli/main.js",
+    "start": "node dist/cli.js",
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "oxlint .",

package/dist/types/contracts/skill-candidate.d.ts

@@ -1,63 +0,0 @@
-export declare const SKILL_CANDIDATE_STATUS_VALUES: readonly ["draft", "in_review", "approved", "rejected", "canary", "published", "stale", "superseded", "rolled_back"];
-export declare const SKILL_CANDIDATE_ACTION_VALUES: readonly ["submit-review", "approve", "reject", "start-canary", "record-effectiveness", "promote", "publish", "mark-stale", "mark-superseded", "rollback"];
-export declare const SKILL_CANDIDATE_EFFECTIVENESS_PHASE_VALUES: readonly ["canary", "published"];
-export type SkillCandidateStatus = (typeof SKILL_CANDIDATE_STATUS_VALUES)[number];
-export type SkillCandidateAction = (typeof SKILL_CANDIDATE_ACTION_VALUES)[number];
-export type SkillCandidateEffectivenessPhase = (typeof SKILL_CANDIDATE_EFFECTIVENESS_PHASE_VALUES)[number];
-export type SkillCandidateArtifactContract = {
-    uri: string;
-    sha256?: string;
-    workspaceDir?: string;
-    relativePath?: string;
-    sourceWorkspaceDir?: string;
-    stagedAt?: string;
-};
-export type SkillCandidateSourceExecutionContract = {
-    executionId?: string;
-    rootExecutionId?: string;
-    parentExecutionId?: string;
-    sidechainId?: string;
-    attemptId?: string;
-    outcomeId?: string;
-    sessionId?: string;
-    turnId?: string;
-};
-export type SkillCandidateReviewContract = {
-    action: SkillCandidateAction;
-    actor?: string | null;
-    notes?: string | null;
-    payload?: Record<string, unknown>;
-    createdAt?: string;
-};
-export type SkillCandidateEffectivenessContract = {
-    phase: SkillCandidateEffectivenessPhase;
-    sampleCount: number;
-    successCount: number;
-    failureCount: number;
-    regressionCount: number;
-    successRate: number;
-    regressionRate: number;
-    avgLatencyMs?: number;
-    avgCostUsd?: number;
-    score?: number;
-    staleReason?: string | null;
-    notes?: string | null;
-    summary?: Record<string, unknown>;
-    lastObservedAt?: string;
-    updatedAt?: string;
-    /** ISO-8601 timestamp of last skill invocation/view/patch activity. */
-    lastActivityAt?: string;
-    /** Cumulative activity count (use + view + patch). */
-    activityCount?: number;
-};
-export declare function coerceSkillCandidateJsonObject(value: unknown): Record<string, unknown>;
-export declare function isSkillCandidateStatus(value: unknown): value is SkillCandidateStatus;
-export declare function isSkillCandidateAction(value: unknown): value is SkillCandidateAction;
-export declare function isSkillCandidateEffectivenessPhase(value: unknown): value is SkillCandidateEffectivenessPhase;
-export declare function normalizeSkillCandidateStatus(value: unknown, fallback?: SkillCandidateStatus): SkillCandidateStatus;
-export declare function normalizeSkillCandidateAction(value: unknown): SkillCandidateAction | null;
-export declare function normalizeSkillCandidateEffectivenessPhase(value: unknown): SkillCandidateEffectivenessPhase | null;
-export declare function normalizeSkillCandidateArtifact(value: unknown): SkillCandidateArtifactContract | null;
-export declare function normalizeSkillCandidateSourceExecution(value: unknown): SkillCandidateSourceExecutionContract | null;
-export declare function normalizeSkillCandidateReview(value: unknown): SkillCandidateReviewContract | null;
-export declare function normalizeSkillCandidateEffectiveness(value: unknown): SkillCandidateEffectivenessContract | null;