@majkapp/plugin-kit 3.7.2 → 3.7.3

package/dist/majk-interface-types.d.ts

@@ -1882,6 +1882,1104 @@ export interface SkillsAPI {
      */
     on(eventType: SkillEventType, handler: (event: SkillEvent) => void): Promise<Unsubscribe>;
 }
+/**
+ * Witness - Recursive structure for verification checks.
+ * Used by delegation and batch services.
+ */
+export interface Witness {
+    bash?: string | {
+        command: string;
+        stdout_contains?: string;
+        stdout_not_contains?: string;
+        stderr_contains?: string;
+        exit_code?: number;
+    };
+    file?: {
+        path: string;
+        contains?: string;
+        not_contains?: string;
+        exists?: boolean;
+        json_path?: string;
+        equals?: any;
+    };
+    files?: string[];
+    http?: {
+        url: string;
+        method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD';
+        status?: number | number[];
+        body_contains?: string;
+        headers?: Record<string, string>;
+        body?: any;
+    };
+    llm?: {
+        prompt: string;
+        file?: string;
+        context?: string;
+    };
+    vision?: {
+        image: string;
+        checklist: string[];
+        context?: string;
+    };
+    js?: {
+        code?: string;
+        file?: string;
+        timeout?: number;
+    };
+    message?: {
+        contains?: string;
+        index?: number;
+        from?: 'user' | 'assistant' | 'any';
+        after_message?: number;
+    };
+    all?: Witness[];
+    any?: Witness[];
+}
+/**
+ * Result from running a witness verification
+ */
+export interface WitnessResult {
+    passed: boolean;
+    evidence: string;
+    strength: 'hard' | 'soft';
+    executionTimeMs: number;
+    children?: WitnessResult[];
+}
+export type DelegationTaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'blocked' | 'abandoned';
+export interface DelegationTeammate {
+    id: string;
+    name: string;
+    skills?: string[];
+    description?: string;
+}
+export interface DelegationTaskResult {
+    success: boolean;
+    summary: string;
+    witnessResults: Array<{
+        witness: string;
+        passed: boolean;
+        evidence: string;
+    }>;
+    verification?: WitnessResult;
+}
+export interface DelegationTaskBlocker {
+    summary: string;
+    task: string;
+    witness: Witness;
+    evidence?: Witness;
+    assignTo: string;
+    reportedAt: Date | string;
+    blockerTaskId?: string;
+}
+export interface DelegationRecentMessage {
+    role: string;
+    content: string;
+    timestamp: Date | string;
+}
+export interface DelegationTaskStatusOutput {
+    taskId: string;
+    status: DelegationTaskStatus;
+    teammateId: string;
+    teammateName: string;
+    result?: DelegationTaskResult;
+    blocker?: DelegationTaskBlocker;
+    recentMessages?: DelegationRecentMessage[];
+    progress?: {
+        messageCount: number;
+        durationMs: number;
+    };
+}
+export interface DelegationBlockerInfo {
+    taskId: string;
+    teammateId: string;
+    teammateName: string;
+    task: string;
+    blocker: DelegationTaskBlocker;
+    reportedAt: string;
+    durationMs: number;
+}
+/**
+ * Delegation API - Multi-agent task delegation with witness-based verification.
+ *
+ * @example
+ * ```typescript
+ * // List available teammates
+ * const { teammates } = await ctx.majk.delegation.list_teammates();
+ *
+ * // Delegate a task
+ * const result = await ctx.majk.delegation.delegate_task({
+ *   teammate: 'code-reviewer',
+ *   task: 'Review the auth module for security issues',
+ *   witness: { bash: 'npm test' }
+ * });
+ *
+ * // Wait for completion
+ * const status = await ctx.majk.delegation.await_task({
+ *   taskId: result.taskId
+ * });
+ * ```
+ */
+export interface DelegationAPI {
+    /**
+     * List all available teammates that can be delegated tasks to.
+     */
+    list_teammates(): Promise<{
+        teammates: DelegationTeammate[];
+        count: number;
+        _hint: string;
+    }>;
+    /**
+     * Delegate a task to a teammate asynchronously.
+     * Returns immediately with a task ID. The task runs in the background.
+     */
+    delegate_task(input: {
+        teammate: string;
+        task: string;
+        context?: Witness;
+        witness: Witness;
+        workingDirectory?: string;
+    }): Promise<{
+        taskId: string;
+        teammateId: string;
+        teammateName: string;
+        conversationId: string;
+        status: 'running';
+        _hint: string;
+    }>;
+    /**
+     * Check the current status of a delegated task.
+     */
+    check_task_status(input: {
+        taskId: string;
+        messageCount?: number;
+    }): Promise<DelegationTaskStatusOutput>;
+    /**
+     * Wait for a task to complete.
+     * Blocks until the task finishes or timeout is reached.
+     */
+    await_task(input: {
+        taskId: string;
+        timeoutMs?: number;
+    }): Promise<DelegationTaskStatusOutput>;
+    /**
+     * Wait for multiple tasks to complete (fan-out/fan-in pattern).
+     */
+    await_tasks(input: {
+        taskIds: string[];
+        timeoutMs?: number;
+    }): Promise<{
+        results: DelegationTaskStatusOutput[];
+        summary: {
+            total: number;
+            completed: number;
+            failed: number;
+            blocked: number;
+            stillRunning: number;
+        };
+        allCompleted: boolean;
+        allSucceeded: boolean;
+    }>;
+    /**
+     * Run a witness to verify something right now.
+     */
+    check_witness(input: {
+        witness: Witness;
+        workingDirectory?: string;
+    }): Promise<WitnessResult>;
+    /**
+     * List all currently blocked tasks with their blocker details.
+     */
+    get_blockers(input?: {
+        teammateId?: string;
+        assignedTo?: string;
+    }): Promise<{
+        blockers: DelegationBlockerInfo[];
+        count: number;
+    }>;
+    /**
+     * Resolve a blocker by updating the task, witness, or sending instructions.
+     */
+    resolve_blocker(input: {
+        taskId: string;
+        action: 'update_task' | 'update_witness' | 'send_instruction' | 'unblock';
+        newTask?: string;
+        newWitness?: Witness;
+        instruction?: string;
+        resolution?: string;
+    }): Promise<{
+        taskId: string;
+        action: string;
+        previousStatus: DelegationTaskStatus;
+        newStatus: DelegationTaskStatus;
+        message: string;
+    }>;
+}
+export type BatchJobStatus = 'pending' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+export type BatchItemStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+export interface BatchInputSource {
+    type: 'list' | 'directory' | 'glob';
+    items?: any[];
+    path?: string;
+    recursive?: boolean;
+    extensions?: string[];
+    exclude?: string[];
+    pattern?: string;
+    basePath?: string;
+    ignore?: string[];
+}
+export interface BatchProcessorConfig {
+    type: 'teammate' | 'rpc' | 'witness' | 'script';
+    teammateId?: string;
+    taskTemplate?: string;
+    context?: Witness;
+    witness?: Witness;
+    workingDirectory?: string;
+    taskTimeoutMs?: number;
+    pluginId?: string;
+    serviceName?: string;
+    functionName?: string;
+    input?: Record<string, any>;
+    code?: string;
+    file?: string;
+    timeoutMs?: number;
+}
+export interface BatchExecutionConfig {
+    maxParallelism?: number;
+    itemTimeoutMs?: number;
+    jobTimeoutMs?: number;
+    retry?: {
+        maxAttempts?: number;
+        backoff?: 'none' | 'fixed' | 'linear' | 'exponential';
+        initialDelayMs?: number;
+        maxDelayMs?: number;
+        jitter?: boolean;
+    };
+}
+export interface BatchProgress {
+    totalItems: number;
+    completedItems: number;
+    failedItems: number;
+    skippedItems?: number;
+    runningItems?: number;
+    pendingItems?: number;
+}
+export interface BatchJob {
+    id: string;
+    name: string;
+    status: BatchJobStatus;
+    statusReason?: string;
+    createdAt: Date | string;
+    startedAt?: Date | string;
+    completedAt?: Date | string;
+    progress: BatchProgress;
+    resultSummary?: any;
+    tags?: string[];
+}
+export interface BatchJobItem {
+    id: string;
+    index: number;
+    status: BatchItemStatus;
+    data: any;
+    result?: any;
+    error?: string;
+    errorCode?: string;
+    attempts?: number;
+    durationMs?: number;
+}
+/**
+ * Batch API - Batch processing for large sets of items.
+ *
+ * @example
+ * ```typescript
+ * // Create a batch job
+ * const { job } = await ctx.majk.batch.create_batch_job({
+ *   name: 'Process files',
+ *   input: { source: { type: 'glob', pattern: 'src/**\/*.ts' } },
+ *   processor: {
+ *     type: 'teammate',
+ *     teammateId: 'code-reviewer',
+ *     taskTemplate: 'Review {{item}}'
+ *   },
+ *   autoStart: true
+ * });
+ *
+ * // Wait for completion
+ * const result = await ctx.majk.batch.await_batch_job({ jobId: job.id });
+ * ```
+ */
+export interface BatchAPI {
+    /**
+     * Create a new batch processing job.
+     */
+    create_batch_job(input: {
+        name: string;
+        description?: string;
+        input: {
+            source: BatchInputSource;
+            transformTemplate?: string;
+            skipIfTemplate?: string;
+            limit?: number;
+        };
+        processor: BatchProcessorConfig;
+        execution?: BatchExecutionConfig;
+        tags?: string[];
+        metadata?: Record<string, any>;
+        autoStart?: boolean;
+    }): Promise<{
+        job: BatchJob;
+        _hint: string;
+    }>;
+    /**
+     * Start a pending batch job.
+     */
+    start_batch_job(input: {
+        jobId: string;
+    }): Promise<{
+        job: BatchJob;
+        _hint: string;
+    }>;
+    /**
+     * Pause a running batch job.
+     */
+    pause_batch_job(input: {
+        jobId: string;
+        reason?: string;
+    }): Promise<{
+        job: BatchJob;
+        _hint: string;
+    }>;
+    /**
+     * Resume a paused batch job.
+     */
+    resume_batch_job(input: {
+        jobId: string;
+    }): Promise<{
+        job: BatchJob;
+    }>;
+    /**
+     * Cancel a batch job.
+     */
+    cancel_batch_job(input: {
+        jobId: string;
+    }): Promise<{
+        job: BatchJob;
+    }>;
+    /**
+     * Get the current status and progress of a batch job.
+     */
+    check_batch_job(input: {
+        jobId: string;
+        includeFailedItems?: boolean;
+        failedItemsLimit?: number;
+    }): Promise<{
+        job: {
+            id: string;
+            name: string;
+            status: BatchJobStatus;
+            statusReason?: string;
+            createdAt: Date | string;
+            startedAt?: Date | string;
+            completedAt?: Date | string;
+        };
+        progress: BatchProgress;
+        resultSummary?: any;
+        failedItems?: Array<{
+            id: string;
+            index: number;
+            data: any;
+            error?: string;
+            errorCode?: string;
+        }>;
+    }>;
+    /**
+     * Wait for a batch job to complete.
+     */
+    await_batch_job(input: {
+        jobId: string;
+        timeoutMs?: number;
+        ignoreBlockers?: boolean;
+    }): Promise<{
+        job: {
+            id: string;
+            name: string;
+            status: BatchJobStatus;
+            statusReason?: string;
+            createdAt: Date | string;
+            startedAt?: Date | string;
+            completedAt?: Date | string;
+        };
+        resultSummary?: any;
+        finalProgress: BatchProgress;
+        hasBlockers?: boolean;
+        blockedCount?: number;
+    }>;
+    /**
+     * List batch jobs with optional filters.
+     */
+    list_batch_jobs(input?: {
+        status?: BatchJobStatus | BatchJobStatus[];
+        tags?: string[];
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        jobs: Array<{
+            id: string;
+            name: string;
+            status: BatchJobStatus;
+            progress: {
+                total: number;
+                completed: number;
+                failed: number;
+            };
+            createdAt: Date | string;
+            tags?: string[];
+        }>;
+        total: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Get items from a batch job with optional status filter.
+     */
+    get_batch_job_items(input: {
+        jobId: string;
+        status?: BatchItemStatus | BatchItemStatus[];
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        items: BatchJobItem[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Get blocked items from a batch job.
+     */
+    get_blocked_batch_items(input: {
+        jobId: string;
+        limit?: number;
+    }): Promise<{
+        items: Array<{
+            id: string;
+            index: number;
+            data: any;
+            error?: string;
+            errorCode?: string;
+            originalData?: any;
+        }>;
+        total: number;
+        _hint?: string;
+    }>;
+    /**
+     * Create a new job to replay failed items from a completed job.
+     */
+    replay_failed_batch_items(input: {
+        jobId: string;
+    }): Promise<{
+        job: BatchJob;
+        _hint: string;
+    }>;
+    /**
+     * Clone a batch job to create a new one with the same configuration.
+     */
+    clone_batch_job(input: {
+        jobId: string;
+        name?: string;
+        tags?: string[];
+    }): Promise<{
+        job: BatchJob;
+        _hint: string;
+    }>;
+}
+export interface ReportSummary {
+    id: string;
+    path: string;
+    uri: string;
+    title?: string;
+    tags?: string[];
+    status?: string;
+    hasWitness: boolean;
+    preview?: string;
+    updatedAt: string;
+    viewPath?: string;
+}
+export interface ReportValidation {
+    status: 'valid' | 'invalid' | 'skipped' | 'no-witness';
+    witness?: WitnessResult;
+}
+export interface ReportWriteResult {
+    id: string;
+    path: string;
+    uri: string;
+    title?: string;
+    hasWitness: boolean;
+    created: boolean;
+}
+export interface ReportReadResult {
+    id: string;
+    path: string;
+    uri: string;
+    title?: string;
+    tags?: string[];
+    status?: string;
+    content: string;
+    totalLines: number;
+    range?: {
+        start: number;
+        end: number;
+    };
+    validation: ReportValidation;
+    updatedAt: string;
+    viewPath?: string;
+    viewName?: string;
+}
+export interface ReportView {
+    id: string;
+    name: string;
+    isDefault: boolean;
+    reportCount: number;
+}
+export interface ReportViewTreeNode {
+    path: string;
+    name: string;
+    report?: ReportSummary;
+    children: ReportViewTreeNode[];
+}
+export interface ReportEdit {
+    line?: number;
+    lines?: [number, number];
+    content?: string;
+    after?: number;
+    delete?: true;
+}
+/**
+ * Reports API - Knowledge management with witness-based validation.
+ *
+ * @example
+ * ```typescript
+ * // Write a report
+ * const result = await ctx.majk.reports.write_report({
+ *   path: '/research/findings.md',
+ *   content: '# Findings\n...',
+ *   tags: ['research']
+ * });
+ *
+ * // Read a report
+ * const report = await ctx.majk.reports.read_report({
+ *   report: result.id
+ * });
+ *
+ * // List reports
+ * const { reports } = await ctx.majk.reports.list_reports({
+ *   pathPrefix: '/research/'
+ * });
+ * ```
+ */
+export interface ReportsAPI {
+    /**
+     * Write a report to the knowledge base.
+     */
+    write_report(input: {
+        content: string;
+        path: string;
+        title?: string;
+        partOf?: {
+            parent: string;
+            placeholder?: string;
+        };
+        refs?: string[];
+        tags?: string[];
+        status?: string;
+        witness?: Witness;
+    }): Promise<ReportWriteResult>;
+    /**
+     * Read a report with embedded content expansion.
+     */
+    read_report(input: {
+        report: string;
+        view?: string;
+        expand?: 'link' | 'inline' | 'inline-linked';
+        expandDepth?: number;
+        offset?: number;
+        limit?: number;
+        validate?: boolean;
+        workingDirectory?: string;
+    }): Promise<ReportReadResult>;
+    /**
+     * List and search reports.
+     */
+    list_reports(input?: {
+        view?: string;
+        pathPrefix?: string;
+        tags?: string[];
+        status?: string;
+        hasWitness?: boolean;
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        reports: ReportSummary[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Delete a report from the knowledge base.
+     */
+    delete_report(input: {
+        report: string;
+    }): Promise<{
+        deleted: boolean;
+    }>;
+    /**
+     * Batch move reports.
+     */
+    reorganize_reports(input: {
+        moves: Array<{
+            from: string;
+            to: string;
+        }>;
+    }): Promise<{
+        message: string;
+        moved: Array<{
+            from: string;
+            to: string;
+            id: string;
+        }>;
+        structure: Record<string, string[]>;
+    }>;
+    /**
+     * Start a new report from a template.
+     */
+    start_report(input: {
+        template: string;
+        topic: string;
+        sections?: Record<string, string>;
+        refs?: Record<string, string | string[]>;
+        validateOnUpdate?: boolean;
+    }): Promise<{
+        handle: string;
+        preview: string;
+        missing: {
+            sections: string[];
+            refs: string[];
+        };
+        warnings?: string[];
+    }>;
+    /**
+     * Update a draft report with new sections or refs.
+     */
+    update_draft(input: {
+        handle: string;
+        sections?: Record<string, string>;
+        refs?: Record<string, string | string[]>;
+    }): Promise<{
+        preview: string;
+        missing: {
+            sections: string[];
+            refs: string[];
+        };
+        validation?: any;
+    }>;
+    /**
+     * Preview a draft report with optional validation.
+     */
+    preview_draft(input: {
+        handle: string;
+        validate?: boolean;
+    }): Promise<{
+        rendered: string;
+        missing: {
+            sections: string[];
+            refs: string[];
+        };
+        validation?: any;
+        ready: boolean;
+    }>;
+    /**
+     * Finalize a draft report - validate and commit.
+     */
+    finalize_report(input: {
+        handle: string;
+        force?: boolean;
+    }): Promise<{
+        success: boolean;
+        report?: ReportWriteResult;
+        validation?: any;
+        error?: {
+            code: string;
+            message: string;
+        };
+        suggestions?: string[];
+    }>;
+    /**
+     * Update an existing report with line-based edits.
+     */
+    update_report(input: {
+        report: string;
+        edits: ReportEdit[];
+        validate?: boolean;
+    }): Promise<{
+        report: ReportWriteResult;
+        validation?: {
+            passed: boolean;
+            status: string;
+            message?: string;
+        };
+    }>;
+    /**
+     * Create a new view with an LLM-powered organization strategy.
+     */
+    create_view(input: {
+        name: string;
+        philosophy: string;
+        categorizeExisting?: boolean;
+    }): Promise<{
+        id: string;
+        name: string;
+        reportsCategorized?: number;
+    }>;
+    /**
+     * List all views in the conversation.
+     */
+    list_views(): Promise<{
+        views: ReportView[];
+    }>;
+    /**
+     * Get the tree structure of a view.
+     */
+    get_view_structure(input: {
+        view: string;
+    }): Promise<{
+        viewId: string;
+        viewName: string;
+        tree: ReportViewTreeNode;
+        reportCount: number;
+    }>;
+    /**
+     * Delete a view (not the default "All" view).
+     */
+    delete_view(input: {
+        view: string;
+    }): Promise<{
+        deleted: boolean;
+        viewName: string;
+    }>;
+    /**
+     * Import a file into the knowledge base.
+     */
+    import_document(input: {
+        file: string;
+        topic?: string;
+        title?: string;
+        tags?: string[];
+        status?: string;
+        cleanup?: boolean;
+    }): Promise<{
+        success: boolean;
+        imported: {
+            source: string;
+            handler: string;
+            reports: Array<{
+                id: string;
+                path: string;
+                title: string;
+                partOf?: string;
+            }>;
+            stats: {
+                totalReports: number;
+                totalCharacters: number;
+                sections?: number;
+            };
+            sourceDeleted?: boolean;
+            cleanupError?: string;
+        };
+    }>;
+    /**
+     * Export a report to a file.
+     */
+    export_report(input: {
+        report: string;
+        outputPath: string;
+        format?: 'markdown' | 'html' | 'pdf' | 'docx';
+        mode?: 'single' | 'hierarchy' | 'inlined';
+        templateId?: string;
+        title?: string;
+        includeFrontmatter?: boolean;
+    }): Promise<{
+        success: boolean;
+        outputPath: string;
+        reportsExported: number;
+        totalSize: number;
+        error?: string;
+        files?: string[];
+    }>;
+    /**
+     * Export all reports to a directory.
+     */
+    export_all_reports(input: {
+        outputDir: string;
+        format?: 'markdown' | 'html' | 'pdf' | 'docx';
+        templateId?: string;
+        includeFrontmatter?: boolean;
+    }): Promise<{
+        message: string;
+        outputDir: string;
+        reportsExported: number;
+        totalSize: number;
+        files: string[];
+        errors?: string[];
+    }>;
+    /**
+     * List available export templates.
+     */
+    list_export_templates(): Promise<{
+        templates: Array<{
+            id: string;
+            name: string;
+            description?: string;
+            category: string;
+        }>;
+        total: number;
+    }>;
+}
+export interface DiscoveredFunction {
+    name: string;
+    description: string;
+    inputSchema: Record<string, any>;
+    identityRequirements?: Array<{
+        identityType: string;
+        required: boolean;
+        description?: string;
+    }>;
+}
+export interface DiscoveredService {
+    pluginId: string;
+    serviceName: string;
+    displayName: string;
+    description: string;
+    isBuiltin: boolean;
+    category?: string;
+    functionCount: number;
+    functions: DiscoveredFunction[];
+}
+/**
+ * Tool Discovery API - Discover available service functions and their schemas.
+ *
+ * @example
+ * ```typescript
+ * // Discover all tools
+ * const { services, summary } = await ctx.majk.toolDiscovery.discover_tools();
+ *
+ * // Get schema for a specific function
+ * const schema = await ctx.majk.toolDiscovery.get_tool_schema({
+ *   functionName: 'delegate_task'
+ * });
+ *
+ * // Invoke a discovered tool dynamically
+ * const result = await ctx.majk.toolDiscovery.invoke_tool({
+ *   functionName: 'list_teammates',
+ *   parameters: {}
+ * });
+ * ```
+ */
+export interface ToolDiscoveryAPI {
+    /**
+     * Discover available service functions that can be called.
+     */
+    discover_tools(input?: {
+        pluginId?: string;
+        category?: string;
+        functionNameContains?: string;
+        builtinOnly?: boolean;
+        requiresIdentity?: string;
+    }): Promise<{
+        services: DiscoveredService[];
+        summary: {
+            totalServices: number;
+            totalFunctions: number;
+            byCategory: Record<string, number>;
+            byPlugin: Record<string, number>;
+        };
+    }>;
+    /**
+     * Get the detailed input schema for a specific function.
+     */
+    get_tool_schema(input: {
+        functionName: string;
+    }): Promise<{
+        function: DiscoveredFunction;
+        service: {
+            pluginId: string;
+            serviceName: string;
+            displayName: string;
+            category?: string;
+        };
+    }>;
+    /**
+     * Get a simple list of all available function names.
+     */
+    list_tool_names(): Promise<{
+        functions: string[];
+        count: number;
+    }>;
+    /**
+     * List all available tool categories.
+     */
+    list_tool_categories(): Promise<{
+        categories: string[];
+        count: number;
+    }>;
+    /**
+     * Get RPC invocation information for a specific function.
+     */
+    get_rpc_invocation_info(input: {
+        functionName: string;
+    }): Promise<{
+        rpcServiceName: string;
+        functionName: string;
+        inputSchema: Record<string, any>;
+        outputSchema?: Record<string, any>;
+        readOnly: boolean;
+        service: {
+            pluginId: string;
+            serviceName: string;
+            displayName: string;
+            category?: string;
+        };
+        identityRequirements?: Array<{
+            identityType: string;
+            required: boolean;
+            description?: string;
+        }>;
+    }>;
+    /**
+     * Invoke any registered service function by name with parameters.
+     */
+    invoke_tool(input: {
+        functionName: string;
+        parameters?: Record<string, any>;
+        timeoutMs?: number;
+    }): Promise<any>;
+}
+export interface ScriptTraceSummary {
+    totalCalls: number;
+    readsExecuted: number;
+    writesMocked: number;
+    errorsEncountered: number;
+    totalDurationMs: number;
+    consoleOutputLines: number;
+    aiMocksUsed: number;
+}
+export interface ScriptTraceEvent {
+    seq: number;
+    timestamp: number;
+    type: string;
+    summary: string;
+    details?: any;
+}
+export interface ScriptToolCallRecord {
+    seq: number;
+    service: string;
+    function: string;
+    params: Record<string, any>;
+    result?: any;
+    error?: string;
+    durationMs: number;
+    wasMocked: boolean;
+    mockSource?: string;
+}
+export interface ScriptError {
+    message: string;
+    name?: string;
+    line?: number;
+    column?: number;
+    codeSnippet?: string;
+}
+/**
+ * Scripting API - Execute JavaScript scripts that orchestrate tool calls.
+ *
+ * @example
+ * ```typescript
+ * // Execute a script
+ * const result = await ctx.majk.scripting.execute_script({
+ *   code: `
+ *     const reports = await tools.ReportsService.list_reports({ limit: 10 });
+ *     console.log('Found', reports.length, 'reports');
+ *     return { count: reports.length };
+ *   `,
+ *   dryRun: true
+ * });
+ *
+ * // Re-run with new parameters
+ * const result2 = await ctx.majk.scripting.execute_script({
+ *   rerun: result.traceId,
+ *   params: { count: 20 }
+ * });
+ * ```
+ */
+export interface ScriptingAPI {
+    /**
+     * Execute JavaScript that orchestrates tool calls.
+     */
+    execute_script(input: {
+        code?: string;
+        rerun?: string;
+        params?: Record<string, unknown>;
+        dryRun?: boolean;
+        dryRunOptions?: {
+            maxAIMocks?: number;
+        };
+        timeoutMs?: number;
+    }): Promise<{
+        success: boolean;
+        result?: any;
+        error?: ScriptError;
+        traceId: string;
+        traceFormatted: string;
+        trace: {
+            summary: ScriptTraceSummary;
+            events: ScriptTraceEvent[];
+            toolCalls?: ScriptToolCallRecord[];
+        };
+    }>;
+    /**
+     * Get full details for a specific tool call from a previous script execution.
+     */
+    expand_trace(input: {
+        traceId: string;
+        callSeq: number;
+    }): Promise<{
+        call: ScriptToolCallRecord;
+        fullParams: string;
+        fullResult: string;
+        functionSchema?: any;
+    }>;
+    /**
+     * List recent script execution traces.
+     */
+    list_traces(): Promise<{
+        traces: Array<{
+            id: string;
+            storedAt: string;
+            summary: {
+                success: boolean;
+                totalCalls: number;
+                durationMs: number;
+                dryRun: boolean;
+            };
+        }>;
+        count: number;
+    }>;
+    /**
+     * Get the full formatted trace output for a previous script execution.
+     */
+    get_trace_formatted(input: {
+        traceId: string;
+    }): Promise<{
+        traceFormatted: string;
+        success: boolean;
+        totalCalls: number;
+        durationMs: number;
+    }>;
+}
 export interface MajkInterface {
     readonly version: string;
     readonly config: ConfigAPI;
@@ -1899,6 +2997,11 @@ export interface MajkInterface {
     readonly knowledge: KnowledgeAPI;
     readonly agents: AgentAPI;
     readonly skills: SkillsAPI;
+    readonly batch: BatchAPI;
+    readonly delegation: DelegationAPI;
+    readonly reports: ReportsAPI;
+    readonly toolDiscovery: ToolDiscoveryAPI;
+    readonly scripting: ScriptingAPI;
 }
 export {};
 //# sourceMappingURL=majk-interface-types.d.ts.map