@jaggerxtrm/specialists 3.7.1 → 3.10.0

package/dist/types/specialist/timeline-query.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Timeline Query Primitives for Feed v2
+ *
+ * Read and merge timeline events across multiple jobs while keeping the flat-file
+ * hot path architecture intact.
+ *
+ * ## Architecture
+ *
+ * - Each job stores events in `.specialists/jobs/<id>/events.jsonl`
+ * - This module reads those files and provides query/merge operations
+ * - No database — direct file reads with efficient streaming
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { readJobEvents, mergeTimelineEvents } from './timeline-query.js';
+ *
+ * // Read events from a single job
+ * const events = readJobEvents('.specialists/jobs/abc123');
+ *
+ * // Merge events from multiple jobs chronologically
+ * const merged = mergeTimelineEvents([
+ *   { jobId: 'abc123', specialist: 'code-review', events: events1 },
+ *   { jobId: 'def456', specialist: 'bug-hunt', events: events2 },
+ * ]);
+ * ```
+ */
+import { type TimelineEvent } from './timeline-events.js';
+/**
+ * Read all timeline events from a single job's events.jsonl file.
+ * Returns events in chronological order (oldest first).
+ * Skips malformed lines non-fatally.
+ */
+export declare function readJobEvents(jobDir: string): TimelineEvent[];
+/**
+ * Read timeline events from a job by ID within a jobs directory.
+ */
+export declare function readJobEventsById(jobsDir: string, jobId: string): TimelineEvent[];
+export interface JobEventsBatch {
+    jobId: string;
+    specialist: string;
+    beadId?: string;
+    events: TimelineEvent[];
+}
+/**
+ * Read events from all jobs in a jobs directory.
+ * Returns batches unsorted — use mergeTimelineEvents for chronological order.
+ */
+export declare function readAllJobEvents(jobsDir: string): JobEventsBatch[];
+/**
+ * Merge timeline events from multiple jobs into a single chronological stream.
+ * Events are sorted by timestamp ascending (oldest first).
+ */
+export declare function mergeTimelineEvents(batches: JobEventsBatch[]): Array<{
+    jobId: string;
+    specialist: string;
+    beadId?: string;
+    event: TimelineEvent;
+}>;
+/**
+ * Filter options for timeline queries.
+ */
+export interface TimelineFilter {
+    /** Minimum timestamp (inclusive) */
+    since?: number;
+    /** Maximum number of events to return */
+    limit?: number;
+    /** Filter by job ID */
+    jobId?: string;
+    /** Filter by specialist name */
+    specialist?: string;
+}
+/**
+ * Apply filters to a merged timeline.
+ */
+export declare function filterTimelineEvents(merged: Array<{
+    jobId: string;
+    specialist: string;
+    beadId?: string;
+    event: TimelineEvent;
+}>, filter: TimelineFilter): Array<{
+    jobId: string;
+    specialist: string;
+    beadId?: string;
+    event: TimelineEvent;
+}>;
+/**
+ * Convenience: read, merge, and filter in one call.
+ */
+export declare function queryTimeline(jobsDir: string, filter?: TimelineFilter): Array<{
+    jobId: string;
+    specialist: string;
+    beadId?: string;
+    event: TimelineEvent;
+}>;
+/**
+ * Get events from the last N minutes.
+ * Useful for feed v2's default snapshot window before follow mode.
+ */
+export declare function getRecentEvents(jobsDir: string, minutesAgo?: number, limit?: number): Array<{
+    jobId: string;
+    specialist: string;
+    beadId?: string;
+    event: TimelineEvent;
+}>;
+/**
+ * Check if a job has completed (has run_complete event).
+ */
+export declare function isJobComplete(events: TimelineEvent[]): boolean;
+/**
+ * Get the completion status of a job from its events.
+ * Returns null if not complete.
+ */
+export declare function getJobCompletionStatus(events: TimelineEvent[]): {
+    status: 'COMPLETE' | 'ERROR' | 'CANCELLED';
+    elapsed_s: number;
+    error?: string;
+    metrics?: Record<string, unknown>;
+} | null;
+/**
+ * Get tool activity summary from events.
+ * Returns array of { tool, start_t, end_t } pairs.
+ */
+export declare function getToolActivity(events: TimelineEvent[]): Array<{
+    tool: string;
+    start_t: number;
+    end_t?: number;
+}>;
+//# sourceMappingURL=timeline-query.d.ts.map

package/dist/types/specialist/timeline-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeline-query.d.ts","sourceRoot":"","sources":["../../../src/specialist/timeline-query.ts"],"names":[],"mappings":"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"}

package/dist/types/specialist/worktree-gc.d.ts

@@ -0,0 +1,24 @@
+export interface WorktreeGcCandidate {
+    readonly jobId: string;
+    readonly worktreePath: string;
+    readonly branch: string | undefined;
+    readonly jobStatus: 'done' | 'error';
+}
+export interface WorktreeGcResult {
+    readonly removed: readonly WorktreeGcCandidate[];
+    readonly skipped: readonly WorktreeGcCandidate[];
+}
+/**
+ * Collect worktree GC candidates from persisted job metadata.
+ * Only considers jobs that are terminal AND recorded a `worktree_path`.
+ * Skips any job whose status is active to prevent accidental removal.
+ */
+export declare function collectWorktreeGcCandidates(jobsDir: string): WorktreeGcCandidate[];
+/**
+ * Prune the provided worktree candidates.
+ * Each removal uses `git worktree remove --force` so the git registry stays consistent.
+ * Failures are silently skipped — prefer missing cleanup over accidental data loss.
+ * Never throws.
+ */
+export declare function pruneWorktrees(candidates: readonly WorktreeGcCandidate[]): WorktreeGcResult;
+//# sourceMappingURL=worktree-gc.d.ts.map

package/dist/types/specialist/worktree-gc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree-gc.d.ts","sourceRoot":"","sources":["../../../src/specialist/worktree-gc.ts"],"names":[],"mappings":"AAmBA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;CACtC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACjD,QAAQ,CAAC,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAClD;AAwBD;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB,EAAE,CAgDlF;AAkBD;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,SAAS,mBAAmB,EAAE,GACzC,gBAAgB,CAclB"}

package/dist/types/specialist/worktree.d.ts

@@ -0,0 +1,69 @@
+export interface WorktreeInfo {
+    /** The git branch checked out in this worktree. */
+    branch: string;
+    /** Absolute path to the worktree directory. */
+    worktreePath: string;
+    /** True when the worktree already existed and was reused; false when freshly created. */
+    reused: boolean;
+}
+export interface WorktreeOptions {
+    /** Bead identifier (e.g. "hgpu.2"). Used as the slug prefix. */
+    beadId: string;
+    /** Specialist name in kebab-case (e.g. "explorer"). */
+    specialistName: string;
+    /**
+     * Absolute path to the directory that will *contain* the new worktree.
+     * Defaults to `<git-common-root>/.worktrees/<beadId>/`.
+     */
+    worktreeBase?: string;
+    /**
+     * Working directory for git/bd commands.
+     * Defaults to `process.cwd()`.
+     */
+    cwd?: string;
+}
+/**
+ * Derive a deterministic, filesystem-safe git branch name.
+ *
+ * Convention: `feature/<beadId>-<specialist-slug>`
+ * Example:    `feature/hgpu.2-explorer`
+ */
+export declare function deriveBranchName(beadId: string, specialistName: string): string;
+/**
+ * Derive a deterministic worktree *directory* name (no path prefix).
+ *
+ * Convention: `<beadId>-<specialist-slug>`
+ * Example:    `hgpu.2-explorer`
+ */
+export declare function deriveWorktreeName(beadId: string, specialistName: string): string;
+/**
+ * Resolve the git common root so all worktrees converge on the same base.
+ * Falls back to `cwd` when git is unavailable (non-git dirs, CI sandboxes).
+ */
+export declare function resolveCommonRoot(cwd: string): string;
+/**
+ * Discover all git worktrees and return a map of `branch → absolute-path`.
+ * Uses `git worktree list --porcelain` which is stable and git-native.
+ *
+ * Detached-HEAD worktrees (no branch line) are omitted.
+ */
+export declare function listWorktrees(cwd?: string): Map<string, string>;
+/**
+ * Find the absolute path of an existing worktree checked out on `branch`.
+ * Returns `undefined` when no matching worktree exists.
+ */
+export declare function findExistingWorktree(branch: string, cwd?: string): string | undefined;
+/**
+ * Ensure an isolated worktree exists for the given bead + specialist pair.
+ *
+ * Behaviour:
+ *   1. Derives the canonical branch name and worktree path.
+ *   2. If a worktree for that branch already exists, returns it (reused=true).
+ *   3. Otherwise calls `bd worktree create <path> --branch <branch>` from the
+ *      git common root.  The call is **hard** — any non-zero exit throws rather
+ *      than falling back to raw `git worktree add`.
+ *
+ * @throws {Error} when `bd worktree create` fails.
+ */
+export declare function provisionWorktree(options: WorktreeOptions): WorktreeInfo;
+//# sourceMappingURL=worktree.d.ts.map

package/dist/types/specialist/worktree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../../src/specialist/worktree.ts"],"names":[],"mappings":"AAeA,MAAM,WAAW,YAAY;IAC3B,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,YAAY,EAAE,MAAM,CAAC;IACrB,yFAAyF;IACzF,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;IACf,uDAAuD;IACvD,cAAc,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAID;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,CAE/E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,CAEjF;AAcD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,SAAgB,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAQtE;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,SAAgB,GAAG,MAAM,GAAG,SAAS,CAE5F;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,eAAe,GAAG,YAAY,CA4BxE"}

package/dist/types/tools/specialist/feed_specialist.tool.d.ts

@@ -0,0 +1,51 @@
+import * as z from 'zod';
+export declare const feedSpecialistSchema: z.ZodObject<{
+    job_id: z.ZodString;
+    cursor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    job_id: string;
+    cursor: number;
+}, {
+    job_id: string;
+    limit?: number | undefined;
+    cursor?: number | undefined;
+}>;
+export declare function createFeedSpecialistTool(jobsDir: string): {
+    name: "feed_specialist";
+    description: string;
+    inputSchema: z.ZodObject<{
+        job_id: z.ZodString;
+        cursor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+        job_id: string;
+        cursor: number;
+    }, {
+        job_id: string;
+        limit?: number | undefined;
+        cursor?: number | undefined;
+    }>;
+    execute(input: z.infer<typeof feedSpecialistSchema>): Promise<{
+        error: string;
+        job_id: string;
+    } | {
+        events: import("../../specialist/timeline-events.js").TimelineEvent[];
+        cursor: number;
+        next_cursor: number;
+        has_more: boolean;
+        is_complete: boolean;
+        metrics?: Record<string, unknown> | undefined;
+        bead_id?: string | undefined;
+        status: string;
+        is_dead: boolean;
+        model?: string | undefined;
+        job_id: string;
+        specialist: string;
+        specialist_model: string;
+        error?: undefined;
+    }>;
+};
+//# sourceMappingURL=feed_specialist.tool.d.ts.map

package/dist/types/tools/specialist/feed_specialist.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feed_specialist.tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/specialist/feed_specialist.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AASzB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAQ/B,CAAC;AAEH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM;;;;;;;;;;;;;;;;mBAY/B,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC;;;;;;;;;;;;;;;;;;;EAkE5D"}

package/dist/types/tools/specialist/list_specialists.tool.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import type { SpecialistLoader } from '../../specialist/loader.js';
+export declare const listSpecialistsSchema: z.ZodObject<{
+    category: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodEnum<["project", "user", "system", "all"]>>;
+}, "strip", z.ZodTypeAny, {
+    category?: string | undefined;
+    scope?: "system" | "user" | "project" | "all" | undefined;
+}, {
+    category?: string | undefined;
+    scope?: "system" | "user" | "project" | "all" | undefined;
+}>;
+export declare function createListSpecialistsTool(loader: SpecialistLoader): {
+    name: "list_specialists";
+    description: string;
+    inputSchema: z.ZodObject<{
+        category: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodEnum<["project", "user", "system", "all"]>>;
+    }, "strip", z.ZodTypeAny, {
+        category?: string | undefined;
+        scope?: "system" | "user" | "project" | "all" | undefined;
+    }, {
+        category?: string | undefined;
+        scope?: "system" | "user" | "project" | "all" | undefined;
+    }>;
+    execute(input: z.infer<typeof listSpecialistsSchema>): Promise<import("../../specialist/loader.js").SpecialistSummary[]>;
+};
+//# sourceMappingURL=list_specialists.tool.d.ts.map

package/dist/types/tools/specialist/list_specialists.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list_specialists.tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/specialist/list_specialists.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,eAAO,MAAM,qBAAqB;;;;;;;;;EAGhC,CAAC;AAEH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,gBAAgB;;;;;;;;;;;;;mBAKzC,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC;EAO7D"}

package/dist/types/tools/specialist/resume_specialist.tool.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import type { JobRegistry } from '../../specialist/jobRegistry.js';
+export declare const resumeSpecialistSchema: z.ZodObject<{
+    job_id: z.ZodString;
+    task: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    task: string;
+    job_id: string;
+}, {
+    task: string;
+    job_id: string;
+}>;
+export declare function createResumeSpecialistTool(registry: JobRegistry): {
+    name: "resume_specialist";
+    description: string;
+    inputSchema: z.ZodObject<{
+        job_id: z.ZodString;
+        task: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        task: string;
+        job_id: string;
+    }, {
+        task: string;
+        job_id: string;
+    }>;
+    execute(input: z.infer<typeof resumeSpecialistSchema>): Promise<{
+        status: string;
+        job_id: string;
+        output: string | undefined;
+        error?: undefined;
+        task?: undefined;
+    } | {
+        status: string;
+        error: string | undefined;
+        job_id: string;
+        output?: undefined;
+        task?: undefined;
+    } | {
+        status: string;
+        job_id: string;
+        task: string;
+        output?: undefined;
+        error?: undefined;
+    }>;
+};
+//# sourceMappingURL=resume_specialist.tool.d.ts.map

package/dist/types/tools/specialist/resume_specialist.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume_specialist.tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/specialist/resume_specialist.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAInE,eAAO,MAAM,sBAAsB;;;;;;;;;EAGjC,CAAC;AAEH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,WAAW;;;;;;;;;;;;;mBASvC,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;EA2C9D"}

package/dist/types/tools/specialist/specialist_init.tool.d.ts

@@ -0,0 +1,26 @@
+import * as z from 'zod';
+import type { SpecialistLoader } from '../../specialist/loader.js';
+export interface SpecialistInitDeps {
+    /** Returns true if the bd CLI is available in PATH. */
+    bdAvailable: () => boolean;
+    /** Returns true if a .beads/ directory exists in cwd. */
+    beadsExists: () => boolean;
+    /** Runs `bd init` and returns the exit status. */
+    bdInit: () => {
+        status: number | null;
+    };
+}
+export declare const specialistInitSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare function createSpecialistInitTool(loader: SpecialistLoader, deps?: SpecialistInitDeps): {
+    name: "specialist_init";
+    description: string;
+    inputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    execute(_input: z.infer<typeof specialistInitSchema>): Promise<{
+        specialists: import("../../specialist/loader.js").SpecialistSummary[];
+        beads: {
+            available: boolean;
+            initialized: boolean;
+        };
+    }>;
+};
+//# sourceMappingURL=specialist_init.tool.d.ts.map

package/dist/types/tools/specialist/specialist_init.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specialist_init.tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/specialist/specialist_init.tool.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,MAAM,WAAW,kBAAkB;IACjC,uDAAuD;IACvD,WAAW,EAAE,MAAM,OAAO,CAAC;IAC3B,yDAAyD;IACzD,WAAW,EAAE,MAAM,OAAO,CAAC;IAC3B,kDAAkD;IAClD,MAAM,EAAE,MAAM;QAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;CACzC;AAED,eAAO,MAAM,oBAAoB,gDAAe,CAAC;AAEjD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,gBAAgB,EAAE,IAAI,CAAC,EAAE,kBAAkB;;;;oBAkBlE,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC;;;;;;;EAqB7D"}

package/dist/types/tools/specialist/specialist_status.tool.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import type { SpecialistLoader } from '../../specialist/loader.js';
+import type { CircuitBreaker } from '../../utils/circuitBreaker.js';
+export declare function createSpecialistStatusTool(loader: SpecialistLoader, circuitBreaker: CircuitBreaker): {
+    name: "specialist_status";
+    description: string;
+    inputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    execute(_: object): Promise<{
+        loaded_count: number;
+        backends_health: {
+            [k: string]: "CLOSED" | "HALF_OPEN" | "OPEN";
+        };
+        specialists: {
+            name: string;
+            scope: "default" | "user" | "package";
+            category: string;
+            version: string;
+            staleness: "OK" | "STALE" | "AGED";
+        }[];
+        background_jobs: {
+            id: any;
+            specialist: any;
+            status: any;
+            is_dead: boolean;
+            elapsed_s: any;
+            current_event: any;
+            bead_id: any;
+            metrics: any;
+            error: any;
+        }[];
+    }>;
+};
+//# sourceMappingURL=specialist_status.tool.d.ts.map

package/dist/types/tools/specialist/specialist_status.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specialist_status.tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/specialist/specialist_status.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAOpE,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,gBAAgB,EAAE,cAAc,EAAE,cAAc;;;;eAK9E,MAAM;;;;;;;;;;;;;;;;;;;;;;;;EAsD1B"}

package/dist/types/tools/specialist/steer_specialist.tool.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import type { JobRegistry } from '../../specialist/jobRegistry.js';
+export declare const steerSpecialistSchema: z.ZodObject<{
+    job_id: z.ZodString;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    job_id: string;
+}, {
+    message: string;
+    job_id: string;
+}>;
+export declare function createSteerSpecialistTool(registry: JobRegistry): {
+    name: "steer_specialist";
+    description: string;
+    inputSchema: z.ZodObject<{
+        job_id: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        job_id: string;
+    }, {
+        message: string;
+        job_id: string;
+    }>;
+    execute(input: z.infer<typeof steerSpecialistSchema>): Promise<{
+        status: string;
+        job_id: string;
+        message: string;
+        error?: undefined;
+    } | {
+        status: string;
+        error: string | undefined;
+        job_id: string;
+        message?: undefined;
+    }>;
+};
+//# sourceMappingURL=steer_specialist.tool.d.ts.map

package/dist/types/tools/specialist/steer_specialist.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steer_specialist.tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/specialist/steer_specialist.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAInE,eAAO,MAAM,qBAAqB;;;;;;;;;EAGhC,CAAC;AAEH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,WAAW;;;;;;;;;;;;;mBAKtC,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC;;;;;;;;;;;EAwC7D"}

package/dist/types/tools/specialist/stop_specialist.tool.d.ts

@@ -0,0 +1,31 @@
+import * as z from 'zod';
+export declare const stopSpecialistSchema: z.ZodObject<{
+    job_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    job_id: string;
+}, {
+    job_id: string;
+}>;
+export declare function createStopSpecialistTool(): {
+    name: "stop_specialist";
+    description: string;
+    inputSchema: z.ZodObject<{
+        job_id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        job_id: string;
+    }, {
+        job_id: string;
+    }>;
+    execute(input: z.infer<typeof stopSpecialistSchema>): Promise<{
+        status: string;
+        job_id: string;
+        pid: number;
+        error?: undefined;
+    } | {
+        status: string;
+        error: any;
+        job_id: string;
+        pid?: undefined;
+    }>;
+};
+//# sourceMappingURL=stop_specialist.tool.d.ts.map

package/dist/types/tools/specialist/stop_specialist.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop_specialist.tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/specialist/stop_specialist.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAIzB,eAAO,MAAM,oBAAoB;;;;;;EAE/B,CAAC;AAEH,wBAAgB,wBAAwB;;;;;;;;;;mBAKf,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC;;;;;;;;;;;EAqC5D"}

package/dist/types/tools/specialist/use_specialist.tool.d.ts

@@ -0,0 +1,93 @@
+import * as z from 'zod';
+import type { SpecialistRunner } from '../../specialist/runner.js';
+export declare const useSpecialistSchema: z.ZodEffects<z.ZodObject<{
+    name: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+    bead_id: z.ZodOptional<z.ZodString>;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    backend_override: z.ZodOptional<z.ZodString>;
+    autonomy_level: z.ZodOptional<z.ZodEnum<["READ_ONLY", "LOW", "MEDIUM", "HIGH"]>>;
+    context_depth: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    prompt?: string | undefined;
+    bead_id?: string | undefined;
+    variables?: Record<string, string> | undefined;
+    backend_override?: string | undefined;
+    autonomy_level?: "READ_ONLY" | "LOW" | "MEDIUM" | "HIGH" | undefined;
+    context_depth?: number | undefined;
+}, {
+    name: string;
+    prompt?: string | undefined;
+    bead_id?: string | undefined;
+    variables?: Record<string, string> | undefined;
+    backend_override?: string | undefined;
+    autonomy_level?: "READ_ONLY" | "LOW" | "MEDIUM" | "HIGH" | undefined;
+    context_depth?: number | undefined;
+}>, {
+    name: string;
+    prompt?: string | undefined;
+    bead_id?: string | undefined;
+    variables?: Record<string, string> | undefined;
+    backend_override?: string | undefined;
+    autonomy_level?: "READ_ONLY" | "LOW" | "MEDIUM" | "HIGH" | undefined;
+    context_depth?: number | undefined;
+}, {
+    name: string;
+    prompt?: string | undefined;
+    bead_id?: string | undefined;
+    variables?: Record<string, string> | undefined;
+    backend_override?: string | undefined;
+    autonomy_level?: "READ_ONLY" | "LOW" | "MEDIUM" | "HIGH" | undefined;
+    context_depth?: number | undefined;
+}>;
+export declare function createUseSpecialistTool(runner: SpecialistRunner): {
+    name: "use_specialist";
+    description: string;
+    inputSchema: z.ZodEffects<z.ZodObject<{
+        name: z.ZodString;
+        prompt: z.ZodOptional<z.ZodString>;
+        bead_id: z.ZodOptional<z.ZodString>;
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        backend_override: z.ZodOptional<z.ZodString>;
+        autonomy_level: z.ZodOptional<z.ZodEnum<["READ_ONLY", "LOW", "MEDIUM", "HIGH"]>>;
+        context_depth: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        prompt?: string | undefined;
+        bead_id?: string | undefined;
+        variables?: Record<string, string> | undefined;
+        backend_override?: string | undefined;
+        autonomy_level?: "READ_ONLY" | "LOW" | "MEDIUM" | "HIGH" | undefined;
+        context_depth?: number | undefined;
+    }, {
+        name: string;
+        prompt?: string | undefined;
+        bead_id?: string | undefined;
+        variables?: Record<string, string> | undefined;
+        backend_override?: string | undefined;
+        autonomy_level?: "READ_ONLY" | "LOW" | "MEDIUM" | "HIGH" | undefined;
+        context_depth?: number | undefined;
+    }>, {
+        name: string;
+        prompt?: string | undefined;
+        bead_id?: string | undefined;
+        variables?: Record<string, string> | undefined;
+        backend_override?: string | undefined;
+        autonomy_level?: "READ_ONLY" | "LOW" | "MEDIUM" | "HIGH" | undefined;
+        context_depth?: number | undefined;
+    }, {
+        name: string;
+        prompt?: string | undefined;
+        bead_id?: string | undefined;
+        variables?: Record<string, string> | undefined;
+        backend_override?: string | undefined;
+        autonomy_level?: "READ_ONLY" | "LOW" | "MEDIUM" | "HIGH" | undefined;
+        context_depth?: number | undefined;
+    }>;
+    execute(input: z.infer<typeof useSpecialistSchema>, onProgress?: (msg: string) => void): Promise<import("../../specialist/runner.js").RunResult | {
+        status: "error";
+        error: string;
+    }>;
+};
+//# sourceMappingURL=use_specialist.tool.d.ts.map

package/dist/types/tools/specialist/use_specialist.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use_specialist.tool.d.ts","sourceRoot":"","sources":["../../../../src/tools/specialist/use_specialist.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAGnE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW9B,CAAC;AAEH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAcvC,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,eAAe,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI;;;;EAgC/F"}

package/dist/types/utils/circuitBreaker.d.ts

@@ -0,0 +1,19 @@
+type State = 'CLOSED' | 'HALF_OPEN' | 'OPEN';
+interface CircuitBreakerOptions {
+    failureThreshold?: number;
+    cooldownMs?: number;
+}
+export declare function isTransientError(error: unknown): boolean;
+export declare function isAuthError(error: unknown): boolean;
+export declare class CircuitBreaker {
+    private states;
+    private threshold;
+    private cooldownMs;
+    constructor(options?: CircuitBreakerOptions);
+    getState(backend: string): State;
+    isAvailable(backend: string): boolean;
+    recordSuccess(backend: string): void;
+    recordFailure(backend: string): void;
+}
+export {};
+//# sourceMappingURL=circuitBreaker.d.ts.map

package/dist/types/utils/circuitBreaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuitBreaker.d.ts","sourceRoot":"","sources":["../../../src/utils/circuitBreaker.ts"],"names":[],"mappings":"AACA,KAAK,KAAK,GAAG,QAAQ,GAAG,WAAW,GAAG,MAAM,CAAC;AAQ7C,UAAU,qBAAqB;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA2BD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAgBxD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAgBnD;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,UAAU,CAAS;gBAEf,OAAO,GAAE,qBAA0B;IAK/C,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK;IAShC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIrC,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAIpC,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CASrC"}

package/dist/types/utils/logger.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Logger utility for consistent logging across the application
+ */
+export declare const logger: {
+    info: (message: string, ...args: any[]) => void;
+    error: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    debug: (message: string, ...args: any[]) => void;
+    progress: (message: string) => void;
+};
+//# sourceMappingURL=logger.d.ts.map