cliskill 1.1.7 → 1.2.0

package/dist/index.d.ts

@@ -45,9 +45,6 @@ declare const providerSchema: z.ZodObject<{
     maxTokens?: number | undefined;
 }>;
 type ProviderConfig = z.infer<typeof providerSchema>;
-/**
- * Schema for the main application configuration.
- */
 declare const appConfigSchema: z.ZodObject<{
     /** Default provider name to use */
     defaultProvider: z.ZodOptional<z.ZodString>;
@@ -139,6 +136,46 @@ declare const appConfigSchema: z.ZodObject<{
         preloadTools?: boolean | undefined;
         streamingOptimizations?: boolean | undefined;
     }>>;
+    /** God mode — cascading escalation engine with 3 tiers */
+    godMode: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        tier: z.ZodDefault<z.ZodNullable<z.ZodEnum<["unchained", "sovereign", "apex"]>>>;
+        autoEscalate: z.ZodDefault<z.ZodBoolean>;
+        maxTier: z.ZodDefault<z.ZodEnum<["unchained", "sovereign", "apex"]>>;
+        bypassPermissions: z.ZodDefault<z.ZodBoolean>;
+        maxConcurrency: z.ZodDefault<z.ZodNumber>;
+        selfModifyPrompt: z.ZodDefault<z.ZodBoolean>;
+        autonomousSpawn: z.ZodDefault<z.ZodBoolean>;
+        modifyProjectConfig: z.ZodDefault<z.ZodBoolean>;
+        autoHeal: z.ZodDefault<z.ZodBoolean>;
+        showBanner: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        tier: "unchained" | "sovereign" | "apex" | null;
+        autoEscalate: boolean;
+        maxTier: "unchained" | "sovereign" | "apex";
+        bypassPermissions: boolean;
+        maxConcurrency: number;
+        selfModifyPrompt: boolean;
+        autonomousSpawn: boolean;
+        modifyProjectConfig: boolean;
+        autoHeal: boolean;
+        showBanner: boolean;
+    }, {
+        enabled?: boolean | undefined;
+        tier?: "unchained" | "sovereign" | "apex" | null | undefined;
+        autoEscalate?: boolean | undefined;
+        maxTier?: "unchained" | "sovereign" | "apex" | undefined;
+        bypassPermissions?: boolean | undefined;
+        maxConcurrency?: number | undefined;
+        selfModifyPrompt?: boolean | undefined;
+        autonomousSpawn?: boolean | undefined;
+        modifyProjectConfig?: boolean | undefined;
+        autoHeal?: boolean | undefined;
+        showBanner?: boolean | undefined;
+    }>>;
+    /** Non-interactive mode — headless execution for CI/CD and automation */
+    /** Model access — unrestricted model selection */
     /** Model access — unrestricted model selection */
     models: z.ZodDefault<z.ZodObject<{
         aliases: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -308,6 +345,19 @@ declare const appConfigSchema: z.ZodObject<{
         preloadTools: boolean;
         streamingOptimizations: boolean;
     };
+    godMode: {
+        enabled: boolean;
+        tier: "unchained" | "sovereign" | "apex" | null;
+        autoEscalate: boolean;
+        maxTier: "unchained" | "sovereign" | "apex";
+        bypassPermissions: boolean;
+        maxConcurrency: number;
+        selfModifyPrompt: boolean;
+        autonomousSpawn: boolean;
+        modifyProjectConfig: boolean;
+        autoHeal: boolean;
+        showBanner: boolean;
+    };
     models: {
         maxContextTokens: number;
         aliases: {
@@ -382,6 +432,19 @@ declare const appConfigSchema: z.ZodObject<{
         preloadTools?: boolean | undefined;
         streamingOptimizations?: boolean | undefined;
     } | undefined;
+    godMode?: {
+        enabled?: boolean | undefined;
+        tier?: "unchained" | "sovereign" | "apex" | null | undefined;
+        autoEscalate?: boolean | undefined;
+        maxTier?: "unchained" | "sovereign" | "apex" | undefined;
+        bypassPermissions?: boolean | undefined;
+        maxConcurrency?: number | undefined;
+        selfModifyPrompt?: boolean | undefined;
+        autonomousSpawn?: boolean | undefined;
+        modifyProjectConfig?: boolean | undefined;
+        autoHeal?: boolean | undefined;
+        showBanner?: boolean | undefined;
+    } | undefined;
     models?: {
         maxContextTokens?: number | undefined;
         aliases?: {
@@ -545,6 +608,412 @@ declare abstract class BaseAdapter implements ProviderAdapter {
     protected fetchWithRetry(url: string, optionsFactory: () => RequestInit): Promise<Response>;
 }
 
+/** A single diagnostic (error/warning) */
+interface Diagnostic {
+    file: string;
+    line?: number;
+    column?: number;
+    severity: 'error' | 'warning';
+    message: string;
+    code?: string;
+}
+/** Result of a verification check */
+interface VerificationResult {
+    passed: boolean;
+    errors: Diagnostic[];
+    warnings: Diagnostic[];
+}
+
+/**
+ * Error Memory Bank — Память ошибок модели
+ *
+ * Каждый раз, когда модель допускает ошибку (compilation error, failed test, bad pattern),
+ * она записывается в Error Memory. При следующем запросе система проверяет
+ * похожие контексты и инжектит предупреждения в промпт.
+ *
+ * Архитектура:
+ * - In-memory + JSON persistence
+ * - Fingerprinting: error pattern → context signature
+ * - Deduplication by similarity
+ * - Decay: старые ошибки постепенно забываются
+ * - Session-scoped + persistent across sessions
+ */
+interface ErrorEntry {
+    /** Unique ID */
+    id: string;
+    /** Which model made this error */
+    model: string;
+    /** Error pattern fingerprint (e.g. "TS6133-unused-variable") */
+    pattern: string;
+    /** Context fingerprint (what was the model trying to do) */
+    contextSignature: string;
+    /** The actual error message */
+    errorMessage: string;
+    /** The file extension when error occurred */
+    fileExtension: string;
+    /** How was it fixed */
+    fix: string;
+    /** Number of times this pattern occurred */
+    occurrences: number;
+    /** First seen timestamp */
+    firstSeen: number;
+    /** Last seen timestamp */
+    lastSeen: number;
+    /** Was it auto-fixed by SmartFix? */
+    autoFixed: boolean;
+}
+interface ErrorMemoryConfig {
+    /** Maximum entries to keep */
+    maxEntries: number;
+    /** Decay time in ms — entries older than this get lower priority */
+    decayTime: number;
+    /** Path to persist error memory JSON */
+    persistencePath: string | null;
+    /** Minimum similarity score (0-1) to consider a match */
+    matchThreshold: number;
+}
+interface ErrorMemoryMatch {
+    entry: ErrorEntry;
+    relevance: number;
+}
+interface RecordErrorInput {
+    model: string;
+    error: string;
+    errorCode?: string;
+    fileExtension: string;
+    context: string;
+    fix?: string;
+    autoFixed?: boolean;
+}
+declare class ErrorMemoryBank {
+    private entries;
+    private config;
+    private dirty;
+    constructor(config?: Partial<ErrorMemoryConfig>);
+    /** Initialize — load from disk if persistence enabled */
+    init(): Promise<void>;
+    /** Persist to disk */
+    save(): Promise<void>;
+    /**
+     * Record a model error.
+     * If a similar pattern already exists, increments occurrence count.
+     */
+    record(input: RecordErrorInput): ErrorEntry;
+    /**
+     * Find similar past errors for a given context.
+     * Returns entries sorted by relevance (most relevant first).
+     */
+    findSimilar(context: string, model?: string, fileExtension?: string): ErrorMemoryMatch[];
+    /**
+     * Generate warning prompt for injection.
+     * Returns a compact list of past errors relevant to the current context.
+     */
+    generateWarningPrompt(context: string, model?: string, fileExtension?: string): string;
+    /** Get all entries (for debugging/inspection) */
+    getAll(): ErrorEntry[];
+    /** Get statistics */
+    getStats(): {
+        totalEntries: number;
+        topPatterns: {
+            pattern: string;
+            count: number;
+        }[];
+    };
+    /** Clear all entries */
+    clear(): void;
+    private fingerprintPattern;
+    private fingerprintContext;
+    private tokenize;
+    private jaccardSimilarity;
+    private computeDecay;
+    private evictOldest;
+    private load;
+}
+
+/**
+ * Shadow Compilation v2 — Тихая компиляция
+ *
+ * Эволюция SVA: невидимый цикл для пользователя.
+ * Модель генерирует код → в фоне компилируем → если ошибки →
+ * кормим обратно модели → перегенерация → пользователь видит ТОЛЬКО рабочий код.
+ *
+ * Pipeline:
+ * 1. Agent generates code
+ * 2. ShadowCompiler intercepts BEFORE showing to user
+ * 3. Runs tsc/eslint/cargo check/etc in background
+ * 4. If errors → feeds back to model with error context
+ * 5. Repeats up to maxIterations
+ * 6. Returns clean code or best-effort with diagnostics
+ *
+ * Integration points:
+ * - VerificationGate.preVerify() → ShadowCompiler.shadowCompile()
+ * - loop.ts tool result → ShadowCompiler.postCompileCheck()
+ */
+
+interface ShadowCompileConfig {
+    /** Enable shadow compilation */
+    enabled: boolean;
+    /** Maximum auto-repair iterations */
+    maxIterations: number;
+    /** Timeout per compilation check (ms) */
+    compileTimeout: number;
+    /** Which compilers to run */
+    compilers: CompilerConfig[];
+    /** Whether to show compilation status to user */
+    showStatus: boolean;
+    /** Error memory integration */
+    errorMemory: ErrorMemoryBank | null;
+}
+interface CompilerConfig {
+    /** Compiler type */
+    type: 'tsc' | 'eslint' | 'cargo' | 'go' | 'python' | 'custom';
+    /** File extensions this compiler handles */
+    extensions: string[];
+    /** Custom command (for 'custom' type) */
+    command?: string;
+    /** Custom args template — {file} is replaced with file path */
+    args?: string[];
+    /** Whether this compiler is enabled */
+    enabled: boolean;
+}
+interface ShadowCompileInput {
+    /** File path (relative to project root) */
+    file: string;
+    /** Content to verify */
+    content: string;
+    /** Which model generated this (for error memory) */
+    model?: string;
+    /** Context of what was requested (for error memory) */
+    requestContext?: string;
+}
+interface ShadowCompileResult {
+    /** Whether compilation passed */
+    passed: boolean;
+    /** Final content (may be modified by auto-repair) */
+    content: string;
+    /** Number of repair iterations performed */
+    iterations: number;
+    /** Diagnostics from each iteration */
+    iterationDiagnostics: Diagnostic[][];
+    /** Final diagnostics (empty if passed) */
+    remainingDiagnostics: Diagnostic[];
+    /** Fixes applied during shadow compilation */
+    fixesApplied: string[];
+    /** Time spent in shadow compilation */
+    durationMs: number;
+}
+interface ShadowCompileEvent {
+    type: 'shadow_compile_start' | 'shadow_compile_iteration' | 'shadow_compile_fix' | 'shadow_compile_end';
+    iteration?: number;
+    file: string;
+    diagnostics?: Diagnostic[];
+    fix?: string;
+    passed: boolean;
+}
+type ShadowCompileEventHandler = (event: ShadowCompileEvent) => void;
+declare class ShadowCompiler {
+    private config;
+    private cwd;
+    private tscPath;
+    private eventHandler;
+    private initialized;
+    constructor(cwd: string, config?: Partial<ShadowCompileConfig>, errorMemory?: ErrorMemoryBank);
+    /** Set event handler for monitoring shadow compilation progress */
+    onEvent(handler: ShadowCompileEventHandler): void;
+    /** Initialize — detect available compilers */
+    init(): Promise<void>;
+    /**
+     * Main entry point: Shadow-compile a file.
+     *
+     * Takes generated content, runs it through compilers,
+     * and auto-repairs errors up to maxIterations.
+     */
+    shadowCompile(input: ShadowCompileInput): Promise<ShadowCompileResult>;
+    /**
+     * Quick post-write check: after file is written, run a final compilation.
+     * Returns diagnostics if any errors remain.
+     */
+    postCompileCheck(file: string): Promise<Diagnostic[]>;
+    private getCompiler;
+    /**
+     * Run compilation for a file.
+     * If content is provided, simulates writing it first (temp file).
+     * If content is null, checks the actual file on disk.
+     */
+    private runCompile;
+    /**
+     * TSC compilation: write content to temp location, run tsc, capture errors.
+     */
+    private runTscCompile;
+    /**
+     * Cargo check for Rust files.
+     * Runs on the whole project since cargo doesn't support single-file checks.
+     */
+    private runCargoCheck;
+    private findCargoDir;
+    private parseTscErrors;
+    private parseCargoErrors;
+    /**
+     * Auto-fix common errors without model round-trip.
+     * Returns fixed content if possible.
+     */
+    private autoFix;
+    private fixOne;
+    private execCommand;
+    private emit;
+}
+
+type GodModeTier = 'unchained' | 'sovereign' | 'apex';
+interface GodModeConfig {
+    /** Whether god mode is enabled at all */
+    enabled: boolean;
+    /** Current escalation tier (starts at null = inactive) */
+    tier: GodModeTier | null;
+    /** Allow auto-escalation (agent can promote itself on complex tasks) */
+    autoEscalate: boolean;
+    /** Maximum tier the agent can reach (safety cap) */
+    maxTier: GodModeTier;
+    /** Auto-approve ALL tool calls without permission checks */
+    bypassPermissions: boolean;
+    /** Maximum parallel tool calls (increases with tier) */
+    maxConcurrency: number;
+    /** Agent can modify its own system prompt at runtime */
+    selfModifyPrompt: boolean;
+    /** Agent can spawn sub-agents without asking */
+    autonomousSpawn: boolean;
+    /** Agent can write to project config files (package.json, tsconfig, etc.) */
+    modifyProjectConfig: boolean;
+    /** Agent auto-heals errors without stopping for confirmation */
+    autoHeal: boolean;
+    /** Print god mode banner on activation */
+    showBanner: boolean;
+}
+interface GodModeState {
+    /** Current active tier */
+    tier: GodModeTier | null;
+    /** Whether god mode is currently active */
+    active: boolean;
+    /** How many times the agent escalated this session */
+    escalationCount: number;
+    /** Timestamps of tier activations */
+    tierHistory: Array<{
+        tier: GodModeTier;
+        timestamp: number;
+    }>;
+    /** Tools auto-approved in this session */
+    autoApprovedCount: number;
+    /** Sub-agents spawned autonomously */
+    subAgentsSpawned: number;
+    /** Errors auto-healed */
+    errorsHealed: number;
+}
+declare class GodModeManager {
+    private config;
+    private state;
+    constructor(config: GodModeConfig);
+    /** Is god mode active at any tier? */
+    isActive(): boolean;
+    /** Current tier (null if inactive) */
+    getTier(): GodModeTier | null;
+    /** Numeric tier level (0 = inactive, 1 = unchained, 2 = sovereign, 3 = apex) */
+    getTierLevel(): number;
+    /** Should we bypass permission checks? */
+    shouldBypassPermissions(): boolean;
+    /** Can agent modify its own system prompt? */
+    canSelfModifyPrompt(): boolean;
+    /** Can agent spawn sub-agents autonomously? */
+    canAutonomousSpawn(): boolean;
+    /** Can agent modify project config files? */
+    canModifyProjectConfig(): boolean;
+    /** Should agent auto-heal errors? */
+    shouldAutoHeal(): boolean;
+    /** Max parallel tool calls */
+    getMaxConcurrency(): number;
+    /** Get full state (for debugging/display) */
+    getState(): Readonly<GodModeState>;
+    /** Get config */
+    getConfig(): Readonly<GodModeConfig>;
+    /** Activate god mode at a specific tier */
+    activate(tier: GodModeTier): GodModeTier;
+    /** Auto-escalate to the next tier (if autoEscalate is enabled) */
+    autoEscalate(): GodModeTier | null;
+    /** Deactivate god mode completely */
+    deactivate(): void;
+    /** Record that a tool was auto-approved */
+    recordAutoApproval(): void;
+    /** Record that a sub-agent was spawned */
+    recordSubAgentSpawned(): void;
+    /** Record that an error was auto-healed */
+    recordErrorHealed(): void;
+    /** Get the god mode system prompt section to inject */
+    getSystemPromptSection(): string;
+    /** Get the system prompt modifier (like fast-mode's getSystemPromptModifier) */
+    getSystemPromptModifier(): string;
+    /** Get permission override — returns true to bypass, false to use normal flow */
+    getPermissionOverride(): boolean;
+    /** Get status string for UI display */
+    getStatusString(): string;
+    private applyTierCapabilities;
+}
+
+/** Configuration for the VerificationGate */
+interface VerificationGateConfig {
+    /** Enable/disable verification entirely */
+    enabled: boolean;
+    /** Maximum number of auto-fix attempts before giving up */
+    maxFixAttempts: number;
+    /** Run import resolution checks */
+    checkImports: boolean;
+    /** Run TypeScript type checking */
+    checkTypes: boolean;
+}
+/**
+ * VerificationGate: the proactive verification layer.
+ *
+ * This sits between the agent's tool calls and the actual file system writes.
+ * Before a file is written/edited, it:
+ *   1. Simulates the write
+ *   2. Runs diagnostics (type check + import resolution)
+ *   3. If errors found → tries SmartFix
+ *   4. Returns verified (possibly fixed) content
+ *
+ * After the write:
+ *   1. Runs post-write diagnostics
+ *   2. Returns confirmation with any warnings
+ */
+declare class VerificationGate {
+    private diagnostics;
+    private smartFix;
+    private config;
+    constructor(cwd: string, config?: Partial<VerificationGateConfig>);
+    /** Initialize the diagnostics engine */
+    init(): Promise<void>;
+    /**
+     * Pre-write verification: simulate writing `content` to `file`
+     * and check for errors. If errors found, try to auto-fix.
+     *
+     * Returns:
+     *  - passed: true if content is safe to write
+     *  - content: possibly fixed content (may differ from input)
+     *  - diagnostics: any remaining errors/warnings
+     *  - fixesApplied: list of auto-fixes applied
+     */
+    preVerify(file: string, content: string): Promise<{
+        passed: boolean;
+        content: string;
+        result: VerificationResult;
+        fixesApplied: string[];
+    }>;
+    /**
+     * Post-write verification: after file was written, check for errors.
+     */
+    postVerify(file: string): Promise<VerificationResult>;
+    /** Update config at runtime */
+    updateConfig(partial: Partial<VerificationGateConfig>): void;
+    /** Get current config */
+    getConfig(): VerificationGateConfig;
+}
+
 /** Events emitted by the agent loop */
 type LoopEvent = {
     type: 'assistant_text';
@@ -597,6 +1066,12 @@ interface ToolExecutionContext {
     sessionId?: string;
     /** P0.2: Progress callback — tools emit intermediate status messages */
     onProgress?: (message: string) => void;
+    /** Verification gate for proactive code verification */
+    verificationGate?: VerificationGate;
+    /** God mode manager — cascading escalation engine */
+    godModeManager?: GodModeManager;
+    /** Shadow compiler — silent compilation with auto-fix for file writes */
+    shadowCompiler?: ShadowCompiler;
 }
 
 /** Risk level of a tool operation */
@@ -878,93 +1353,6 @@ declare class FastModeManager {
     updateConfig(partial: Partial<FastModeConfig>): void;
 }
 
-/** Role definition for a plan mode agent */
-interface PlanAgentRole {
-    name: string;
-    description: string;
-    systemPromptSuffix: string;
-    allowedTools: string[];
-    maxSteps: number;
-}
-/** Configuration for plan mode */
-interface PlanModeConfig {
-    enabled: boolean;
-    maxParallelAgents: number;
-    agentRoles: PlanAgentRole[];
-    planningStrategy: 'sequential' | 'parallel' | 'adaptive';
-    maxStepsPerAgent: number;
-    contextSharing: boolean;
-}
-/** Single step in a plan */
-interface PlanStep {
-    id: string;
-    description: string;
-    assignedAgent: string;
-    status: 'pending' | 'in-progress' | 'completed' | 'failed';
-    result?: string;
-    dependencies: string[];
-}
-/** A plan with steps and metadata */
-interface Plan {
-    id: string;
-    goal: string;
-    steps: PlanStep[];
-    status: 'planning' | 'executing' | 'completed' | 'failed';
-    createdAt: Date;
-    completedAt?: Date;
-}
-/** Statistics for plan execution */
-interface PlanStats {
-    totalSteps: number;
-    completedSteps: number;
-    failedSteps: number;
-    totalDuration: number;
-    agentStats: Record<string, {
-        steps: number;
-        success: number;
-        failed: number;
-    }>;
-}
-/**
- * Manages plan mode lifecycle: creation, configuration, state.
- * Does NOT execute plans — that is PlanExecutor's job.
- */
-declare class PlanModeManager {
-    private config;
-    private activePlan;
-    constructor(config?: Partial<PlanModeConfig>);
-    /** Current configuration */
-    getConfig(): PlanModeConfig;
-    /** Update configuration */
-    updateConfig(partial: Partial<PlanModeConfig>): void;
-    /** Whether plan mode is enabled */
-    isEnabled(): boolean;
-    /** Enable plan mode */
-    enable(): void;
-    /** Disable plan mode */
-    disable(): void;
-    /** Get the active plan */
-    getActivePlan(): Plan | null;
-    /** Create a new plan from a goal */
-    createPlan(goal: string, steps: Omit<PlanStep, 'status'>[]): Plan;
-    /** Mark plan as executing */
-    startExecution(plan: Plan): void;
-    /** Mark plan as completed */
-    completePlan(plan: Plan): void;
-    /** Mark plan as failed */
-    failPlan(plan: Plan): void;
-    /** Get a role by name */
-    getRole(name: string): PlanAgentRole | undefined;
-    /** Get all roles */
-    getRoles(): PlanAgentRole[];
-    /** Compute statistics for a plan */
-    computeStats(plan: Plan): PlanStats;
-    /** Format a plan as a human-readable string */
-    formatPlan(plan: Plan): string;
-    /** Format execution stats as a human-readable report */
-    formatStats(stats: PlanStats): string;
-}
-
 interface ContextWindowConfig {
     maxTokens: number;
     compactionThreshold: number;
@@ -1077,8 +1465,9 @@ interface LoopDeps {
     autoModeManager?: AutoModeManager;
     /** Fast mode manager (optional — created from config if not provided) */
     fastModeManager?: FastModeManager;
+    /** God mode manager (optional — cascading escalation engine with 3 tiers) */
+    godModeManager?: GodModeManager;
     /** Plan mode manager (optional — enables multi-agent plan execution) */
-    planModeManager?: PlanModeManager;
     /** Context window manager (optional — created from config if not provided) */
     contextWindowManager?: ContextWindowManager;
     /** Session history — messages from previous turns in this conversation */
@@ -1239,13 +1628,13 @@ declare const lspInputSchema: z.ZodObject<{
     character: z.ZodOptional<z.ZodNumber>;
     query: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    operation: "go_to_definition" | "find_references" | "hover" | "document_symbols" | "workspace_symbols";
+    operation: "document_symbols" | "hover" | "go_to_definition" | "find_references" | "workspace_symbols";
     file_path: string;
     query?: string | undefined;
     line?: number | undefined;
     character?: number | undefined;
 }, {
-    operation: "go_to_definition" | "find_references" | "hover" | "document_symbols" | "workspace_symbols";
+    operation: "document_symbols" | "hover" | "go_to_definition" | "find_references" | "workspace_symbols";
     file_path: string;
     query?: string | undefined;
     line?: number | undefined;
@@ -1262,13 +1651,13 @@ declare class LspTool extends BaseTool<typeof lspInputSchema> {
         character: z.ZodOptional<z.ZodNumber>;
         query: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        operation: "go_to_definition" | "find_references" | "hover" | "document_symbols" | "workspace_symbols";
+        operation: "document_symbols" | "hover" | "go_to_definition" | "find_references" | "workspace_symbols";
         file_path: string;
         query?: string | undefined;
         line?: number | undefined;
         character?: number | undefined;
     }, {
-        operation: "go_to_definition" | "find_references" | "hover" | "document_symbols" | "workspace_symbols";
+        operation: "document_symbols" | "hover" | "go_to_definition" | "find_references" | "workspace_symbols";
         file_path: string;
         query?: string | undefined;
         line?: number | undefined;
@@ -1547,56 +1936,144 @@ declare class EnhancedMemoryStore {
     private persist;
 }
 
-/** A skill definition loaded from a .md file or registered programmatically */
+/** Skill status in the lifecycle */
+type SkillStatus = 'installed' | 'enabled' | 'disabled' | 'error' | 'loading' | 'builtin';
+/** Input parameter definition for a skill */
+interface SkillParamDef {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'file' | 'directory' | 'select' | 'multiselect';
+    label: string;
+    description?: string;
+    required?: boolean;
+    default?: unknown;
+    options?: {
+        value: string;
+        label: string;
+    }[];
+    placeholder?: string;
+}
+/** Output type a skill produces */
+interface SkillOutput {
+    type: 'text' | 'markdown' | 'code' | 'diff' | 'json' | 'file' | 'files';
+    description?: string;
+}
+/** A single step in a skill's execution plan */
+interface SkillStep {
+    id: string;
+    title: string;
+    prompt: string;
+    tools?: string[];
+    timeout?: number;
+    condition?: string;
+    outputs?: SkillOutput[];
+}
+/** Trigger definition — when a skill auto-activates */
+interface SkillTrigger {
+    event: 'file-change' | 'command' | 'keyword' | 'schedule' | 'manual';
+    pattern?: string;
+    description?: string;
+}
+/** The full skill manifest (metadata + execution plan) */
+interface SkillManifest {
+    id: string;
+    name: string;
+    version: string;
+    description: string;
+    author?: string;
+    icon?: string;
+    category: SkillCategory;
+    tags?: string[];
+    params: SkillParamDef[];
+    steps: SkillStep[];
+    outputs: SkillOutput[];
+    triggers?: SkillTrigger[];
+    requiresTools?: string[];
+    requiresProviders?: string[];
+    modelPreference?: 'fast' | 'smart' | 'code' | 'creative' | 'reasoning';
+    source: 'builtin' | 'local' | 'marketplace';
+    sourcePath?: string;
+    marketplaceUrl?: string;
+    readme?: string;
+}
+/** Skill categories for organization */
+type SkillCategory = 'code-review' | 'refactoring' | 'testing' | 'documentation' | 'debugging' | 'deployment' | 'security' | 'analysis' | 'workflow' | 'agent' | 'performance' | 'custom';
+/** Runtime state of an installed skill */
+interface InstalledSkill {
+    manifest: SkillManifest;
+    status: SkillStatus;
+    installedAt: number;
+    lastUsedAt?: number;
+    useCount: number;
+    error?: string;
+    enabled: boolean;
+}
+/** A running skill execution instance */
+interface SkillExecution {
+    id: string;
+    skillId: string;
+    startedAt: number;
+    completedAt?: number;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+    currentStep: number;
+    params: Record<string, unknown>;
+    results: SkillStepResult[];
+    error?: string;
+}
+/** Result of a single step execution */
+interface SkillStepResult {
+    stepId: string;
+    status: 'completed' | 'failed' | 'skipped';
+    output?: string;
+    duration?: number;
+    error?: string;
+}
+/** Legacy compatibility — kept for existing skill-loader.ts */
 interface SkillDefinition {
-    /** Unique name */
+    id: string;
     name: string;
-    /** Human-readable description */
+    version: string;
     description: string;
-    /** Aliases for invocation */
-    aliases?: string[];
-    /** The prompt template to inject when skill is activated */
     prompt: string;
-    /** List of tools this skill is allowed to use (empty = all) */
-    allowedTools?: string[];
-    /** Whether this skill is built-in or user-defined */
-    builtin: boolean;
-    /** Source file path (for user-defined skills) */
-    sourcePath?: string;
+    tools?: string[];
+    modelPreference?: string;
+    category?: string;
+    tags?: string[];
+    params?: SkillParamDef[];
 }
 
-/**
- * Registry of available skills.
- * Manages skill registration, lookup, and loading from disk.
- */
 declare class SkillRegistry {
     private skills;
-    private aliasIndex;
-    /** Register a skill */
-    register(skill: SkillDefinition): void;
-    /** Get a skill by name or alias */
-    get(nameOrAlias: string): SkillDefinition | undefined;
-    /** Get all registered skills */
-    getAll(): SkillDefinition[];
-    /** Check if a skill exists */
-    has(name: string): boolean;
-    /** Unregister a skill */
-    unregister(name: string): void;
-    /**
-     * Load skills from a directory.
-     * Returns the number of skills loaded.
-     */
-    loadFromDir(dir: string): Promise<number>;
-    /**
-     * Load skills from standard locations:
-     * 1. ~/.cliskill/skills/ (global user skills)
-     * 2. .cliskill/skills/ (project skills)
-     */
-    loadStandardSkills(projectRoot: string): Promise<number>;
-    /**
-     * Get skill prompt for injection into system prompt.
-     */
-    getSkillPrompt(nameOrAlias: string): string | undefined;
+    private executions;
+    private listeners;
+    /** Load built-in skills into registry */
+    loadBuiltinSkills(): void;
+    /** Register a skill from external source (file, marketplace, etc.) */
+    registerSkill(manifest: SkillManifest, sourcePath?: string): InstalledSkill;
+    /** Unregister a skill by id */
+    unregisterSkill(id: string): boolean;
+    getAll(): InstalledSkill[];
+    getById(id: string): InstalledSkill | undefined;
+    getByCategory(category: SkillCategory): InstalledSkill[];
+    getEnabled(): InstalledSkill[];
+    getBuiltin(): InstalledSkill[];
+    getCustom(): InstalledSkill[];
+    search(query: string): InstalledSkill[];
+    enableSkill(id: string): boolean;
+    disableSkill(id: string): boolean;
+    toggleSkill(id: string): boolean;
+    startExecution(skillId: string, params: Record<string, unknown>): SkillExecution;
+    completeExecution(executionId: string, stepResults: SkillStepResult[]): void;
+    failExecution(executionId: string, error: string): void;
+    getExecution(executionId: string): SkillExecution | undefined;
+    getRecentExecutions(limit?: number): SkillExecution[];
+    /** Export a skill definition as a legacy SkillDefinition */
+    toSkillDefinition(id: string): SkillDefinition | undefined;
+    /** Serialize all skills for persistence */
+    serialize(): string;
+    /** Restore from serialized state */
+    deserialize(json: string): void;
+    onChange(listener: () => void): () => void;
+    private notify;
 }
 
 /** Permission mode for the session */
@@ -1731,12 +2208,39 @@ interface BudgetStatus {
     percent: number;
     remainingBudget?: number;
 }
+interface TaskSpend {
+    taskId: string;
+    cost: number;
+    inputTokens: number;
+    outputTokens: number;
+    entries: number;
+}
+interface BudgetSnapshot {
+    sessionCost: number;
+    sessionLimit: number | null;
+    sessionPercent: number;
+    taskCost: number;
+    taskLimit: number | null;
+    taskPercent: number;
+    level: BudgetLevel;
+    canContinue: boolean;
+}
 declare class CostTracker {
     private entries;
     private config;
     private sessionStart;
     private lastBudgetLevel;
+    private currentTaskId;
+    private taskCostMap;
     constructor(config?: Partial<CostConfig>);
+    /** Set the current task ID for per-task tracking */
+    setTaskId(taskId: string): void;
+    /** Clear current task ID */
+    clearTaskId(): void;
+    /** Get per-task spend */
+    getTaskSpend(taskId: string): TaskSpend | undefined;
+    /** Get current task cost (if a task is active) */
+    getCurrentTaskCost(): number;
     /** Find prices for a model — exact match first, then fuzzy pattern matching */
     private findPrices;
     /** Record token usage for a model */
@@ -1780,6 +2284,21 @@ declare class CostTracker {
     getSessionDuration(): number;
     /** Reset for new session */
     reset(): void;
+    /**
+     * Get a snapshot of current budget state for enforcement decisions.
+     * `taskLimit` and `sessionLimit` are passed in from AppConfig since
+     * CostTracker itself only tracks spending — limits come from config.
+     */
+    getSnapshot(sessionLimit: number, taskLimit: number): BudgetSnapshot;
+    /**
+     * Whether the agent loop must stop right now.
+     * Checks both session and task limits.
+     */
+    shouldStop(sessionLimit: number, taskLimit: number): boolean;
+    /** Check if budget level changed since last check, emit level */
+    checkLevelChange(): BudgetLevel | null;
+    /** Update the tracked level (called after getSnapshot) */
+    setLevel(level: BudgetLevel): void;
 }
 
 interface TokenBudgetAnalysis {
@@ -1971,6 +2490,40 @@ declare class ContextCompactor {
     private estimateMessagesTokens;
 }
 
+type AgentRole = 'coordinator' | 'worker' | 'reviewer';
+interface AgentConfig {
+    id: string;
+    name: string;
+    role: AgentRole;
+    model?: string;
+    tools?: string[];
+    maxTurns?: number;
+    systemPrompt?: string;
+}
+interface SwarmMessage {
+    from: string;
+    to: string | '*';
+    type: 'task' | 'result' | 'query' | 'response' | 'shutdown';
+    content: string;
+    timestamp: number;
+}
+interface SwarmResult {
+    agentId: string;
+    agentName: string;
+    task: string;
+    result: string;
+    success: boolean;
+    duration: number;
+    turns: number;
+}
+interface SubTask {
+    id: string;
+    description: string;
+    assignedTo?: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    result?: string;
+}
+
 type HookEvent = 'pre_tool_use' | 'post_tool_use' | 'pre_query' | 'post_query' | 'on_error' | 'on_stop';
 interface HookCondition {
     tool_name?: string;
@@ -2153,7 +2706,6 @@ type MCPConnectionState = 'disconnected' | 'connecting' | 'connected' | 'failed'
 declare class MCPClient {
     private readonly config;
     private process;
-    private rl;
     private connectionState;
     private nextId;
     private readonly pendingRequests;
@@ -2161,6 +2713,9 @@ declare class MCPClient {
     private serverInfo;
     private serverInstructions;
     private connectReject;
+    private incomingBuffer;
+    private readingHeaders;
+    private currentHeaders;
     constructor(config: MCPServerConfig);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
@@ -2176,10 +2731,15 @@ declare class MCPClient {
     getCapabilities(): MCPInitializeResult['capabilities'];
     getConfig(): MCPServerConfig;
     private spawnProcess;
+    /**
+     * Parse incoming bytes using MCP stdio Content-Length framing.
+     * Format: Content-Length: <N>\r\n\r\n<N bytes of JSON>
+     */
+    private handleData;
+    private handleMessage;
     private performHandshake;
     private sendRequest;
     private sendNotification;
-    private handleLine;
     private handleProcessError;
     private handleProcessExit;
     private assertNoError;
@@ -2203,40 +2763,6 @@ declare class MCPConnectionManager {
 declare function executeAgentTask(taskId: string, manager: TaskManager, adapter: ProviderAdapter, tools: ToolRegistry, prompt: string, signal?: AbortSignal): Promise<void>;
 declare function executeShellTask(taskId: string, manager: TaskManager, command: string, cwd: string, signal?: AbortSignal): Promise<void>;
 
-type AgentRole = 'coordinator' | 'worker' | 'reviewer';
-interface AgentConfig {
-    id: string;
-    name: string;
-    role: AgentRole;
-    model?: string;
-    tools?: string[];
-    maxTurns?: number;
-    systemPrompt?: string;
-}
-interface SwarmMessage {
-    from: string;
-    to: string | '*';
-    type: 'task' | 'result' | 'query' | 'response' | 'shutdown';
-    content: string;
-    timestamp: number;
-}
-interface SwarmResult {
-    agentId: string;
-    agentName: string;
-    task: string;
-    result: string;
-    success: boolean;
-    duration: number;
-    turns: number;
-}
-interface SubTask {
-    id: string;
-    description: string;
-    assignedTo?: string;
-    status: 'pending' | 'running' | 'completed' | 'failed';
-    result?: string;
-}
-
 declare class SwarmCoordinator {
     private adapter;
     private tools;
@@ -2248,6 +2774,7 @@ declare class SwarmCoordinator {
     removeAgent(id: string): void;
     getAgents(): AgentConfig[];
     sendMessage(message: SwarmMessage): Promise<void>;
+    getMessages(agentId: string): SwarmMessage[];
     executeSwarm(task: string): Promise<SwarmResult[]>;
     shutdown(): void;
     private findAgentByRole;