@recombine-ai/bosun 0.16.1 → 0.16.2-cloud-2

package/dist/types/backend/config/router.d.ts

@@ -0,0 +1,16 @@
+import type { TRPCRootObject } from '@trpc/server/unstable-core-do-not-import';
+import type { TrpcContext } from '../lib/trpc-context';
+export declare function createConfigRouter(t: TRPCRootObject<TrpcContext, any, any>): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("../lib/bosun-context").BosunContext;
+    meta: any;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    capabilities: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            editable: boolean;
+        };
+        meta: any;
+    }>;
+}>>;

package/dist/types/backend/index.d.ts

@@ -0,0 +1,9 @@
+import { type BosunAgent, type StartBosunOptions } from './lib/options';
+export type { BosunAgent, StartBosunOptions };
+export { withPromptCacheKey } from './prompt-cache';
+export interface Bosun {
+    url: string;
+    loadAgents(agents: BosunAgent[]): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function startBosun(options?: StartBosunOptions): Promise<Bosun>;

package/dist/types/backend/lib/agent-registry.d.ts

@@ -0,0 +1,20 @@
+import type { TestAgentFactory } from '@recombine-ai/bosun-lib';
+import type { BosunAgent } from './options';
+export interface RegisteredAgent {
+    id: string;
+    name: string;
+    promptsDir: string;
+    testsDir: string;
+    createAgent: TestAgentFactory;
+}
+export interface AgentRegistry {
+    list(): RegisteredAgent[];
+    listAgentIds(): string[];
+    get(agentId: string): RegisteredAgent;
+}
+/**
+ * The registry holds the only process-wide agent state Bosun keeps: the project's descriptors.
+ * No agent instances, no context, no conversation history.
+ */
+export declare function setAgents(list: BosunAgent[]): void;
+export declare function getAgentRegistry(): AgentRegistry;

package/dist/types/backend/lib/apply-v4a-diff.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Applies the headerless V4A format emitted by the Responses API Apply Patch tool.
+ * Adapted from the MIT-licensed OpenAI Agents SDK implementation:
+ * https://github.com/openai/openai-agents-js/blob/main/packages/agents-core/src/utils/applyDiff.ts
+ */
+export declare function applyV4ADiff(input: string, diff: string): string;

package/dist/types/backend/lib/bosun-context.d.ts

@@ -0,0 +1,19 @@
+import OpenAI from 'openai';
+import { type AgentRegistry } from './agent-registry';
+import type { BosunConfig } from './options';
+import type { TelescopeSourceConfig } from '../telescope/sources';
+export interface BosunContext {
+    /** Absolute path to the directory Bosun may write generated data into. */
+    dataDir: string;
+    /** Whether Bosun may write prompt and test files back into the project. */
+    editable: boolean;
+    agents: AgentRegistry;
+    telescopeSources: TelescopeSourceConfig[];
+    piiSanitizerModel?: string;
+    openai: OpenAI;
+}
+/**
+ * Built per request, never captured, so that later versions can vary any of these per caller
+ * without touching the call sites.
+ */
+export declare function createBosunContext(config: BosunConfig): BosunContext;

package/dist/types/backend/lib/decode-html-entities.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Decodes HTML entities (named and numeric) in a string.
+ * - Tolerates missing semicolons like `&quot`
+ * - Leaves unknown entities untouched
+ * - Repeats up to 3 times to handle nested encodings like `"`
+ */
+export declare function decodeHtmlEntities(text: string): string;

package/dist/types/backend/lib/options.d.ts

@@ -0,0 +1,51 @@
+import type OpenAI from 'openai';
+import { z } from 'zod';
+import type { TestAgentFactory } from '@recombine-ai/bosun-lib';
+import { type TelescopeSourceConfig } from '../telescope/sources';
+export interface BosunAgent {
+    /** Stable key. Used for conversation files, test suite keys and UI routing. */
+    id: string;
+    /** UI label. */
+    name: string;
+    /** Directory containing this agent's prompt .md and schema.ts files. */
+    promptsDir: string;
+    /** Directory holding <testId>.yaml suites. Default: `${promptsDir}/bosun-tests`. */
+    testsDir?: string;
+    createAgent: TestAgentFactory;
+}
+declare const StartBosunOptionsSchema: z.ZodObject<{
+    host: z.ZodDefault<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    ui: z.ZodDefault<z.ZodBoolean>;
+    editable: z.ZodDefault<z.ZodBoolean>;
+    dataDir: z.ZodDefault<z.ZodString>;
+    telescopeSources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        label: z.ZodString;
+        baseUrl: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        apiKey: z.ZodOptional<z.ZodString>;
+        secret: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    openai: z.ZodDefault<z.ZodObject<{
+        apiKey: z.ZodOptional<z.ZodString>;
+        client: z.ZodOptional<z.ZodCustom<OpenAI, OpenAI>>;
+        piiSanitizerModel: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StartBosunOptions = z.input<typeof StartBosunOptionsSchema>;
+export interface BosunConfig {
+    host: string;
+    port: number;
+    ui: boolean;
+    editable: boolean;
+    dataDir: string;
+    telescopeSources: TelescopeSourceConfig[];
+    openai: {
+        apiKey?: string;
+        client?: OpenAI;
+        piiSanitizerModel?: string;
+    };
+}
+export declare function resolveConfig(options?: StartBosunOptions): BosunConfig;
+export {};

package/dist/types/backend/lib/trpc-context.d.ts

@@ -0,0 +1,5 @@
+import type { TRPCRootObject } from '@trpc/server/unstable-core-do-not-import';
+import type { BosunContext } from './bosun-context';
+export type TrpcContext = BosunContext;
+/** A procedure that refuses to run unless Bosun may write to project source. */
+export declare function writeProcedure(t: TRPCRootObject<TrpcContext, any, any>): import("@trpc/server").TRPCProcedureBuilder<BosunContext, any, {}, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;

package/dist/types/backend/lib/voice-agent-lifecycle.d.ts

@@ -0,0 +1,2 @@
+import type { Message } from '@recombine-ai/engine';
+export declare function sendCallStartMessage(result: unknown, sendMessage: (message: string | Message) => Promise<void>): Promise<void>;

package/dist/types/backend/prompt-cache.d.ts

@@ -0,0 +1,17 @@
+interface PromptCacheClient {
+    chat?: {
+        completions?: unknown;
+    };
+    responses?: unknown;
+}
+/**
+ * Bosun runs each test inside this context, so anything the project calls during a test run can see
+ * it, however deep the call tree.
+ */
+export declare function withTestPromptCacheBust<T>(run: () => Promise<T>): Promise<T>;
+/**
+ * Wraps an OpenAI client so requests made during a Bosun test run carry a unique
+ * `prompt_cache_key`. Inert everywhere else, so it is safe in production code.
+ */
+export declare function withPromptCacheKey<T extends PromptCacheClient>(client: T): T;
+export {};

package/dist/types/backend/roleplay/agent-introspection.d.ts

@@ -0,0 +1,29 @@
+import type { StepDef } from '@recombine-ai/engine';
+import type { TestAgent, TestVoiceAgent } from '@recombine-ai/bosun-lib';
+import type { BosunContext } from '../lib/bosun-context';
+export declare function isVoiceAgent(agent: TestAgent): agent is TestVoiceAgent;
+/**
+ * Builds a throwaway agent purely to read its declarations (steps, prompt-context mapper, medium).
+ * Nothing here may be reused for an actual conversation turn.
+ */
+export declare function introspectAgent(bosun: BosunContext, agentId: string): Promise<{
+    agent: TestAgent;
+    steps: StepDef[];
+    ctx: {
+        "__#private@#private": any;
+        set<P extends never>(path: P extends any[] ? P : never, value: P extends [infer First, ...infer Rest] ? First extends never ? Rest["length"] extends 0 ? {}[First] : Rest extends [infer First, ...infer Rest] ? First extends keyof {}[First] ? Rest["length"] extends 0 ? {}[First][First] : Rest extends [infer First, ...infer Rest] ? First extends keyof {}[First][First] ? Rest["length"] extends 0 ? {}[First][First][First] : Rest extends [infer First, ...infer Rest] ? First extends keyof {}[First][First][First] ? Rest["length"] extends 0 ? {}[First][First][First][First] : Rest extends [infer First, ...infer Rest] ? First extends keyof {}[First][First][First][First] ? Rest["length"] extends 0 ? {}[First][First][First][First][First] : Rest extends [infer First, ...infer Rest] ? First extends keyof {}[First][First][First][First][First] ? Rest["length"] extends 0 ? {}[First][First][First][First][First][First] : Rest extends [infer First, ...infer Rest] ? First extends keyof {}[First][First][First][First][First][First] ? Rest["length"] extends 0 ? {}[First][First][First][First][First][First][First] : Rest extends [infer First, ...infer Rest] ? First extends keyof {}[First][First][First][First][First][First][First] ? Rest["length"] extends 0 ? {}[First][First][First][First][First][First][First][First] : Rest extends [infer First, ...infer Rest] ? First extends keyof {}[First][First][First][First][First][First][First][First] ? Rest["length"] extends 0 ? {}[First][First][First][First][First][First][First][First][First] : Rest extends [infer First, ...infer Rest] ? First extends keyof {}[First][First][First][First][First][First][First][First][First] ? Rest["length"] extends 0 ? {}[First][First][First][First][First][First][First][First][First][First] : Rest extends [infer First, ...infer Rest] ? First extends keyof {}[First][First][First][First][First][First][First][First][First][First] ? Rest["length"] extends 0 ? {}[First][First][First][First][First][First][First][First][First][First][First] : /*elided*/ any : never : never : never : never : never : never : never : never : never : never : never : never : never : never : never : never : never : never : never : never : never : never): void;
+        set(newContext: {}): void;
+        get(): {};
+        swap(newContext: {}): void;
+        subscribe: (listener: (context: {}) => void) => () => boolean;
+        setPromptContextMapper(promptMapper: (ctx: {}) => object): void;
+        getPromptContextMapper(): (ctx: {}) => object;
+    };
+    basePath: string;
+}>;
+export declare function getAgentSteps(bosun: BosunContext, agentId: string): Promise<{
+    steps: StepDef[];
+    basePath: string;
+}>;
+export declare function getPromptContextMapper(bosun: BosunContext, agentId: string): Promise<(ctx: {}) => object>;
+export declare function readStepSchema(basePath: string, promptPath: string): Promise<string | undefined>;

package/dist/types/backend/roleplay/conversation-store.d.ts

@@ -0,0 +1,23 @@
+import type { Message } from '@recombine-ai/engine';
+import type { BosunContext } from '../lib/bosun-context';
+import { type Conversation, type ConversationHeader, type ConversationMedium } from '../../lib/conversation';
+export declare function newEntryId(): string;
+export declare function createConversation(ctx: BosunContext, input: {
+    agentId: string;
+    medium: ConversationMedium;
+    context: Record<string, unknown>;
+}): Promise<Conversation>;
+export declare function loadConversation(ctx: BosunContext, conversationId: string): Promise<Conversation>;
+export declare function saveConversation(ctx: BosunContext, conversation: Conversation): Promise<void>;
+export declare function deleteConversation(ctx: BosunContext, conversationId: string): Promise<void>;
+export declare function listConversations(ctx: BosunContext, agentId: string): Promise<ConversationHeader[]>;
+/**
+ * Drops `fromTurn` and everything after it, and returns the inbound message that started that turn
+ * so the caller can replay it. This is how "regenerate" works now that conversations never branch.
+ */
+export declare function truncateConversation(ctx: BosunContext, conversationId: string, fromTurn: number): Promise<{
+    conversation: Conversation;
+    inboundMessage: Message | null;
+}>;
+/** Serialises turns for one conversation so two clients cannot interleave writes to its file. */
+export declare function withConversationLock<T>(conversationId: string, fn: () => Promise<T>): Promise<T>;

package/dist/types/backend/roleplay/conversations-router.d.ts

@@ -0,0 +1,59 @@
+import type { TRPCRootObject } from '@trpc/server/unstable-core-do-not-import';
+import type { TrpcContext } from '../lib/trpc-context';
+export declare function createConversationsRouter(t: TRPCRootObject<TrpcContext, any, any>): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("../lib/bosun-context").BosunContext;
+    meta: any;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    list: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            agentId: string;
+        };
+        output: import("../../lib/conversation").ConversationHeader[];
+        meta: any;
+    }>;
+    get: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            conversationId: string;
+        };
+        output: import("../../lib/conversation").Conversation;
+        meta: any;
+    }>;
+    create: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agentId: string;
+        };
+        output: import("../../lib/conversation").Conversation;
+        meta: any;
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            conversationId: string;
+        };
+        output: {
+            ok: boolean;
+        };
+        meta: any;
+    }>;
+    truncate: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            conversationId: string;
+            fromTurn: number;
+        };
+        output: {
+            inboundMessage: import("@recombine-ai/engine").Message | null;
+        };
+        meta: any;
+    }>;
+    updateContext: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            conversationId: string;
+            context: Record<string, unknown>;
+        };
+        output: {
+            ok: false;
+        };
+        meta: any;
+    }>;
+}>>;

package/dist/types/backend/roleplay/logger.d.ts

@@ -0,0 +1,7 @@
+import type { LogEntry } from '../../lib/ws-message';
+export declare function createLogger(sendMessage: (msg: LogEntry) => void): {
+    log: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+};

package/dist/types/backend/roleplay/prompt-edit-progress.d.ts

@@ -0,0 +1,11 @@
+export type PromptEditProgressPhase = 'thinking' | 'drafting' | 'reviewing';
+export type PromptEditProgress = {
+    id: string;
+    phase: PromptEditProgressPhase;
+    activity: number;
+    summary: string;
+    updatedAt: number;
+};
+export declare function updatePromptEditProgress(id: string, progress: Pick<PromptEditProgress, 'phase' | 'activity' | 'summary'>): void;
+export declare function getPromptEditProgress(id: string): PromptEditProgress | null;
+export declare function deletePromptEditProgress(id: string): void;

package/dist/types/backend/roleplay/prompt-edit-proposals.d.ts

@@ -0,0 +1,23 @@
+export type PromptEditProposal = {
+    id: string;
+    agentId: string;
+    step: string;
+    originalPrompt: string;
+    suggestedPrompt: string;
+    createdAt: number;
+};
+export interface PromptEditTestSourceGuard {
+    suiteKey: string;
+    testId: string;
+    allowedFingerprints: string[];
+}
+type StoredPromptEditProposal = PromptEditProposal & {
+    testSourceGuard?: PromptEditTestSourceGuard;
+};
+export declare function createPromptEditProposal(proposal: Omit<PromptEditProposal, 'id' | 'createdAt'> & {
+    testSourceGuard?: PromptEditTestSourceGuard;
+}): PromptEditProposal;
+export declare function getPromptEditProposal(id: string): PromptEditProposal | null;
+export declare function getPromptEditProposalForAcceptance(id: string): StoredPromptEditProposal | null;
+export declare function deletePromptEditProposal(id: string): boolean;
+export {};

package/dist/types/backend/roleplay/prompt-file.d.ts

@@ -0,0 +1,8 @@
+import type { BosunContext } from '../lib/bosun-context';
+export interface LockedPromptFile {
+    path: string;
+    read: () => Promise<string>;
+    write: (prompt: string) => Promise<void>;
+}
+export declare function readEditablePrompt(ctx: BosunContext, agentId: string, stepName: string): Promise<string>;
+export declare function withPromptFileLock<T>(ctx: BosunContext, agentId: string, stepName: string, operation: (file: LockedPromptFile) => Promise<T>): Promise<T>;

package/dist/types/backend/roleplay/router.d.ts

@@ -0,0 +1,191 @@
+import type { TRPCRootObject } from '@trpc/server/unstable-core-do-not-import';
+import { type TrpcContext } from '../lib/trpc-context';
+export declare function createRolePlayRouter(t: TRPCRootObject<TrpcContext, any, any>): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("../lib/bosun-context").BosunContext;
+    meta: any;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    list: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: string[];
+        meta: any;
+    }>;
+    catalog: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            id: string;
+            displayName: string;
+        }[];
+        meta: any;
+    }>;
+    get: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            agentId: string;
+        };
+        output: {
+            id: string;
+            type: "text" | "voice";
+            steps: {
+                name: string;
+                type: "streaming-response" | "streaming-detect" | "text";
+                prompt: string;
+                schema: string | undefined;
+            }[];
+        };
+        meta: any;
+    }>;
+    analyzeTrace: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agentId: string;
+            renderedPrompt: string;
+            stringifiedConversation: string;
+            response: string;
+            traceId?: string | undefined;
+            eventName?: string | undefined;
+            createdAt?: number | undefined;
+            model?: string | undefined;
+            stepTrace?: unknown;
+        };
+        output: import("../tests/analyze").AnalyzeRunResult;
+        meta: any;
+    }>;
+    generateUserResponse: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            stringifiedConversation: string;
+            response: string;
+            model?: string | undefined;
+        };
+        output: {
+            text: string;
+        };
+        meta: any;
+    }>;
+    savePrompt: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agentId: string;
+            step: string;
+            prompt: string;
+        };
+        output: {
+            ok: boolean;
+        };
+        meta: any;
+    }>;
+    suggestPromptEdit: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agentId: string;
+            step: string;
+            request: string;
+            progressId: string;
+        };
+        output: {
+            status: "unchanged";
+            proposal?: undefined;
+        } | {
+            status: "changed";
+            proposal: import("./prompt-edit-proposals").PromptEditProposal;
+        };
+        meta: any;
+    }>;
+    suggestTestFix: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            agentId: string;
+            testId: string;
+            step: string;
+            request: string;
+            prompt: string;
+            basePrompt: string;
+            currentIncorrectOutcome: string;
+            progressId: string;
+        };
+        output: {
+            history: {
+                status: "unchanged";
+                proposal?: undefined;
+            } | {
+                status: "changed";
+                proposal: import("../tests/test-history-edit-proposals").TestHistoryEditProposal;
+            };
+            prompt: {
+                status: "unchanged";
+                proposal?: undefined;
+            } | {
+                status: "changed";
+                proposal: import("./prompt-edit-proposals").PromptEditProposal;
+            };
+        };
+        meta: any;
+    }>;
+    promptEditProgress: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            id: string;
+        };
+        output: import("./prompt-edit-progress").PromptEditProgress | null;
+        meta: any;
+    }>;
+    promptEditProposal: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            id: string;
+        };
+        output: import("./prompt-edit-proposals").PromptEditProposal | null;
+        meta: any;
+    }>;
+    acceptPromptEdit: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            ok: boolean;
+            prompt: string;
+        };
+        meta: any;
+    }>;
+    rejectPromptEdit: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            ok: boolean;
+        };
+        meta: any;
+    }>;
+    userMessageHistory: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            agentId: string;
+        };
+        output: {
+            text: string;
+            lastSeen: number;
+            uses: number;
+        }[];
+        meta: any;
+    }>;
+    generateVariants: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            conversationId: string;
+            context?: Record<string, unknown> | null | undefined;
+            promptOverrides?: Record<string, string> | undefined;
+            count?: number | undefined;
+        };
+        output: import("./variants").GeneratedVariant[];
+        meta: any;
+    }>;
+    commitVariant: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            conversationId: string;
+            entries: any[];
+        };
+        output: {
+            ok: boolean;
+        };
+        meta: any;
+    }>;
+    context: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            agentId: string;
+        };
+        output: object;
+        meta: any;
+    }>;
+}>>;

package/dist/types/backend/roleplay/run-turn.d.ts

@@ -0,0 +1,17 @@
+import type { Message } from '@recombine-ai/engine';
+import type { BosunContext } from '../lib/bosun-context';
+import { type Conversation, type ConversationEntry } from '../../lib/conversation';
+import { type PromptOverrides } from './step-registry';
+export type TurnKind = 'start' | 'message' | 'hangup';
+export interface RunTurnInput {
+    conversation: Conversation;
+    kind: TurnKind;
+    message?: Message;
+    promptOverrides?: PromptOverrides;
+    onEntry: (entry: ConversationEntry) => void;
+}
+/**
+ * Runs exactly one turn against a throwaway agent instance. Every produced entry is appended to
+ * `conversation` and streamed through `onEntry`. Nothing is kept after this function returns.
+ */
+export declare function runTurn(bosun: BosunContext, input: RunTurnInput): Promise<Conversation>;

package/dist/types/backend/roleplay/scheduler.d.ts

@@ -0,0 +1,20 @@
+import type { Logger, Scheduler } from '@recombine-ai/engine';
+export type DelayedActions = Record<string, {
+    at: string | null;
+}>;
+export type DelayedActionRegistry<T> = Record<string, {
+    at: string | null;
+    handler: (data: T) => Promise<unknown>;
+    data: T | null;
+}>;
+export interface BosunScheduler extends Scheduler {
+    triggerAction: (actionName: string) => Promise<void>;
+    serialize: () => DelayedActions;
+    setState(state: DelayedActions): void;
+}
+interface Props {
+    logger: Logger;
+    onUpdate: (actions: DelayedActions) => void;
+}
+export declare function createScheduler({ logger, onUpdate }: Props, delayedActions?: DelayedActionRegistry<string>): BosunScheduler;
+export {};

package/dist/types/backend/roleplay/step-registry.d.ts

@@ -0,0 +1,7 @@
+import type { Logger, StepDef } from '@recombine-ai/engine';
+export type PromptOverrides = Record<string, string>;
+export declare function createStepRegistry(logger: Logger, initialOverrides?: PromptOverrides): {
+    addStep(def: StepDef): void;
+    getSteps: () => StepDef[];
+    setPromptOverrides(next: PromptOverrides): void;
+};

package/dist/types/backend/roleplay/suggest-file-edit.d.ts

@@ -0,0 +1,13 @@
+import type { BosunContext } from '../lib/bosun-context';
+import type { PromptEditProgressPhase } from './prompt-edit-progress';
+export declare function suggestFileEdit(ctx: BosunContext, input: {
+    request: string;
+    originalContent: string;
+    virtualPath: string;
+    instructions: string;
+    onProgress?: (progress: {
+        phase: PromptEditProgressPhase;
+        activity: number;
+        summary: string;
+    }) => void;
+}): Promise<string>;

package/dist/types/backend/roleplay/suggest-prompt-edit.d.ts

@@ -0,0 +1,11 @@
+import type { BosunContext } from '../lib/bosun-context';
+import type { PromptEditProgressPhase } from './prompt-edit-progress';
+export declare function suggestPromptEdit(ctx: BosunContext, input: {
+    request: string;
+    originalPrompt: string;
+    onProgress?: (progress: {
+        phase: PromptEditProgressPhase;
+        activity: number;
+        summary: string;
+    }) => void;
+}): Promise<string>;

package/dist/types/backend/roleplay/suggest-test-fix.d.ts

@@ -0,0 +1,29 @@
+import type { BosunContext } from '../lib/bosun-context';
+import { suggestTestHistoryEdit } from '../tests/suggest-test-history-edit';
+import type { PromptEditProgressPhase } from './prompt-edit-progress';
+import { suggestPromptEdit } from './suggest-prompt-edit';
+type Progress = {
+    phase: PromptEditProgressPhase;
+    activity: number;
+    summary: string;
+};
+interface SuggestTestFixInput {
+    request: string;
+    originalPrompt: string;
+    context: string;
+    conversation: string;
+    expectedOutput: string;
+    assertionLabel: string;
+    assertionValue: string;
+    currentIncorrectOutcome: string;
+    onProgress?: (progress: Progress) => void;
+}
+interface SuggestTestFixDependencies {
+    suggestHistory: typeof suggestTestHistoryEdit;
+    suggestPrompt: typeof suggestPromptEdit;
+}
+export declare function suggestTestFix(ctx: BosunContext, input: SuggestTestFixInput, dependencies?: SuggestTestFixDependencies): Promise<{
+    suggestedConversation: string;
+    suggestedPrompt: string;
+}>;
+export {};

package/dist/types/backend/roleplay/trace-serialization.d.ts

@@ -0,0 +1 @@
+export declare function normalizeTracePayload<T>(value: T): T;

package/dist/types/backend/roleplay/variants.d.ts

@@ -0,0 +1,18 @@
+import { type Conversation, type ConversationEntry } from '../../lib/conversation';
+import type { BosunContext } from '../lib/bosun-context';
+import type { PromptOverrides } from './step-registry';
+export interface GeneratedVariant {
+    id: string;
+    text: string;
+    entries: ConversationEntry[];
+}
+/**
+ * Re-runs the conversation's last turn `count` times without touching the stored conversation.
+ * `commitVariant` is what actually replaces the turn.
+ */
+export declare function generateReplyVariants(ctx: BosunContext, props: {
+    conversation: Conversation;
+    count: number;
+    context?: Record<string, unknown>;
+    promptOverrides?: PromptOverrides;
+}): Promise<GeneratedVariant[]>;