@majkapp/plugin-kit 3.7.1 → 3.7.3

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

@@ -1573,6 +1573,1413 @@ export interface ConfigAPI {
      */
     getAll(): Record<string, any>;
 }
+/**
+ * Context passed to skill setup/teardown functions
+ */
+export interface SkillContext {
+    /** ID of the teammate enabling the skill */
+    teammateId: string;
+    /** ID of the current conversation */
+    conversationId: string;
+    /** Root directory of the project */
+    projectRootDir: string;
+    /** Workspace directory for the project */
+    projectWorkspaceDir: string;
+}
+/**
+ * Setup function signature - called when skill is enabled
+ * Returns additional context/instructions to prepend to skill instructions
+ */
+export type SkillSetupFn = (context: SkillContext) => Promise<string | void>;
+/**
+ * Teardown function signature - called when skill is disabled
+ */
+export type SkillTeardownFn = (context: SkillContext) => Promise<void>;
+/**
+ * Base skill definition - shared between DB and runtime skills
+ */
+export interface SkillDefinition {
+    /** Unique identifier for the skill */
+    id: string;
+    /** Display name for the skill */
+    name: string;
+    /** One-sentence description of what the skill does */
+    description: string;
+    /** Full instructions on how to accomplish tasks using this skill's tools */
+    instructions: string;
+    /** Optional tags for categorization and search */
+    tags?: string[];
+    /** Optional list of tool names this skill uses */
+    tools?: string[];
+    /** Whether the skill is currently enabled */
+    enabled: boolean;
+}
+/**
+ * Runtime-registered skill (can have functions)
+ * Functions are not serialized - they exist only in memory
+ */
+export interface RuntimeSkill extends SkillDefinition {
+    /**
+     * Optional setup function - called when skill is enabled.
+     * Can return additional instructions to prepend to the skill.
+     */
+    setup?: SkillSetupFn;
+    /**
+     * Optional teardown function - called when skill is disabled.
+     * Not currently used but reserved for future use.
+     */
+    teardown?: SkillTeardownFn;
+    /** Source of the runtime skill (for debugging) */
+    source?: string;
+}
+/**
+ * Unified skill type returned from list/search operations
+ * Omits functions since they don't serialize
+ */
+export interface Skill extends SkillDefinition {
+    /** Whether this skill is from the database (true) or runtime (false) */
+    persisted: boolean;
+    /** Whether this skill has a setup function */
+    hasSetup: boolean;
+    /** Whether this skill has a teardown function */
+    hasTeardown: boolean;
+    /** Source of the skill */
+    source: 'database' | 'runtime';
+}
+/**
+ * Summary of a skill for listing
+ */
+export interface SkillSummary {
+    /** Skill ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** One-sentence description */
+    description: string;
+    /** Whether enabled */
+    enabled: boolean;
+    /** Source */
+    source: 'database' | 'runtime';
+    /** Tags */
+    tags?: string[];
+}
+export interface AddSkillInput {
+    /** Unique identifier (auto-generated if not provided) */
+    id?: string;
+    /** Display name */
+    name: string;
+    /** One-sentence description */
+    description: string;
+    /** Full instructions */
+    instructions: string;
+    /** Optional tags */
+    tags?: string[];
+    /** Optional tool names */
+    tools?: string[];
+    /** Initial enabled state (default: true) */
+    enabled?: boolean;
+}
+export interface UpdateSkillInput {
+    /** Skill ID to update */
+    id: string;
+    /** Updated name */
+    name?: string;
+    /** Updated description */
+    description?: string;
+    /** Updated instructions */
+    instructions?: string;
+    /** Updated tags */
+    tags?: string[];
+    /** Updated tools */
+    tools?: string[];
+    /** Updated enabled state */
+    enabled?: boolean;
+}
+export interface SearchSkillsInput {
+    /** Free text query to search across name, description, instructions, tags */
+    query: string;
+    /** Limit results */
+    limit?: number;
+    /** Include disabled skills */
+    includeDisabled?: boolean;
+}
+export interface EnableSkillInput {
+    /** Skill ID or name to enable */
+    skill: string;
+}
+export interface DisableSkillInput {
+    /** Skill ID or name to disable */
+    skill: string;
+}
+export interface DeleteSkillInput {
+    /** Skill ID to delete */
+    id: string;
+}
+export interface ListSkillsResult {
+    skills: SkillSummary[];
+    total: number;
+}
+export interface SearchSkillsResult {
+    /** Skills that match the query well */
+    matching: SkillSummary[];
+    /** Skills that might be relevant */
+    related: SkillSummary[];
+    total: number;
+}
+export interface EnableSkillResult {
+    /** Skill ID */
+    id: string;
+    /** Skill name */
+    name: string;
+    /** The full instructions to use */
+    instructions: string;
+    /** Additional setup instructions (if setup was called) */
+    setupInstructions?: string;
+    /** Tools used by this skill */
+    tools?: string[];
+    /** Whether setup was executed */
+    setupExecuted: boolean;
+}
+export interface AddSkillResult {
+    id: string;
+    name: string;
+    description: string;
+}
+export interface UpdateSkillResult {
+    id: string;
+    name: string;
+    updated: boolean;
+}
+export type SkillEventType = 'skill_added' | 'skill_updated' | 'skill_deleted' | 'skill_enabled' | 'skill_disabled' | 'runtime_skill_registered' | 'runtime_skill_unregistered';
+export interface SkillEvent {
+    type: SkillEventType;
+    skillId: string;
+    timestamp: Date;
+    data?: any;
+}
+/**
+ * Skills API - Provides access to skill discovery, management, and enablement.
+ *
+ * Skills are instructions on how to accomplish tasks using tools.
+ * They can be:
+ * - Database-persisted: Created via add(), no setup/teardown
+ * - Runtime-registered: Created via registerRuntime(), can have setup/teardown
+ *
+ * @example
+ * ```typescript
+ * // List all available skills
+ * const { skills } = await ctx.majk.skills.list();
+ *
+ * // Search for skills
+ * const results = await ctx.majk.skills.search(conversationId, { query: 'code review' });
+ *
+ * // Enable a skill (calls setup if available)
+ * const result = await ctx.majk.skills.enable(context, { skill: 'code-review-mode' });
+ * console.log(result.instructions);
+ *
+ * // Register a runtime skill with setup/teardown
+ * await ctx.majk.skills.registerRuntime({
+ *   id: 'my-skill',
+ *   name: 'My Custom Skill',
+ *   description: 'Does something useful',
+ *   instructions: 'Follow these steps...',
+ *   enabled: true,
+ *   setup: async (ctx) => 'Additional context from setup',
+ *   teardown: async (ctx) => { cleanup(); }
+ * });
+ * ```
+ */
+export interface SkillsAPI {
+    /**
+     * List all available skills.
+     *
+     * @param conversationId - Optional conversation ID for scoped skills
+     * @param includeDisabled - Include disabled skills in results
+     * @returns List of skill summaries
+     */
+    list(conversationId?: string, includeDisabled?: boolean): Promise<ListSkillsResult>;
+    /**
+     * Search skills by query.
+     *
+     * @param conversationId - Optional conversation ID for scoped skills
+     * @param input - Search parameters
+     * @returns Matching and related skills
+     */
+    search(conversationId: string | undefined, input: SearchSkillsInput): Promise<SearchSkillsResult>;
+    /**
+     * Get a skill by ID.
+     *
+     * @param skillId - The skill ID
+     * @returns Full skill data or null if not found
+     */
+    getById(skillId: string): Promise<Skill | null>;
+    /**
+     * Add a new skill to the database.
+     *
+     * @param conversationId - Optional conversation ID for scoped skills
+     * @param input - Skill data
+     * @returns Created skill summary
+     */
+    add(conversationId: string | undefined, input: AddSkillInput): Promise<AddSkillResult>;
+    /**
+     * Update an existing skill in the database.
+     *
+     * @param input - Update data including skill ID
+     * @returns Updated skill summary
+     */
+    update(input: UpdateSkillInput): Promise<UpdateSkillResult>;
+    /**
+     * Delete a skill from the database.
+     *
+     * @param input - Delete parameters
+     * @returns True if deleted
+     */
+    delete(input: DeleteSkillInput): Promise<boolean>;
+    /**
+     * Enable a skill and get its instructions.
+     * Calls the skill's setup() function if available.
+     *
+     * @param context - Skill context with conversation and project info
+     * @param input - Enable parameters
+     * @returns Skill instructions and setup result
+     */
+    enable(context: SkillContext, input: EnableSkillInput): Promise<EnableSkillResult>;
+    /**
+     * Disable a skill.
+     *
+     * @param conversationId - Conversation ID
+     * @param input - Disable parameters
+     * @returns True if disabled
+     */
+    disable(conversationId: string, input: DisableSkillInput): Promise<boolean>;
+    /**
+     * Register a runtime skill (with optional setup/teardown).
+     * Runtime skills are not persisted and exist only in memory.
+     *
+     * @param skill - Runtime skill definition
+     */
+    registerRuntime(skill: RuntimeSkill): Promise<void>;
+    /**
+     * Unregister a runtime skill.
+     *
+     * @param skillId - The skill ID to unregister
+     * @returns True if the skill was found and removed
+     */
+    unregisterRuntime(skillId: string): Promise<boolean>;
+    /**
+     * Get a runtime skill by ID (if it exists).
+     *
+     * @param skillId - The skill ID
+     * @returns Runtime skill or undefined
+     */
+    getRuntime(skillId: string): Promise<RuntimeSkill | undefined>;
+    /**
+     * Subscribe to skill events.
+     *
+     * @param eventType - The event type to listen for
+     * @param handler - Event handler function
+     * @returns Unsubscribe function
+     */
+    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;
@@ -1589,6 +2996,12 @@ export interface MajkInterface {
     readonly mcpServers: MCPServerAPI;
     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