@crewx/sdk 0.9.0-rc.17 → 0.9.0-rc.170

package/dist/facade/Crewx.d.ts

@@ -1,13 +1,21 @@
+import type { AgentListSnapshot } from '../agent/agent-list-view';
+import { type InterceptorLaneRun, type InterceptorPhase } from '../agent-interceptor';
 import { TypedEventEmitter } from '../events/TypedEventEmitter';
 import type { CrewxPlugin } from '../plugin';
 import type { IFsAdapter } from '../platform/IFsAdapter';
 import type { ChannelAdapterRegistration } from '../adapter/types';
-import type { CrewxProjectConfig, AgentConfig, CrewxOptions, QueryOptions, QueryResult, ExecuteOptions, ExecuteResult } from '../types';
-import type { TemplateContext } from '../template/types';
-import type { CustomLayoutDefinition } from '../layout/types';
-import type { TemplateMessage } from '../conversation/types';
+import type { CrewxProjectConfig, AgentConfig, CrewxOptions, QueryOptions, QueryResult, ExecuteOptions, ExecuteResult, CanResumeSessionParams, CanResumeSessionResult } from '../types';
+import type { PromptListResolver, TemplateContext } from '../template/types';
+import type { CustomLayoutDefinition, LayoutCapabilities } from '../layout/types';
+import type { ConversationThreadState, SemanticContinuityContext, TemplateMessage } from '../conversation/types';
 import type { HandlerOptions, CrewxHandler } from '../server/handler';
 import type { RemoteProviderConfig } from '../remote/types.js';
+import type { McpAppLayoutSnapshot, McpAppStateDescriptor } from '../mcp-app/types.js';
+import type { McpAppModelContext } from '../mcp-app/model-context.js';
+import type { CrewxAppCatalogOptions, CrewxAppCatalogResult } from '../mcp-app/types.js';
+import type { McpAppsContext } from '../mcp-app/apps-context.js';
+import type { UiRuntimeFacade, UiRuntimeOptions } from '../ui-instance/types.js';
+import type { CrewxEventName, CrewxEventPayload } from '../events/types';
 export interface ToolDefinition {
     name: string;
     description: string;
@@ -19,6 +27,7 @@ export type LayoutSpec = string | {
     props?: Record<string, any>;
 } | {
     template: string;
+    capabilities?: LayoutCapabilities;
 };
 export interface SkillEntry {
     metadata: {
@@ -28,6 +37,7 @@ export interface SkillEntry {
     };
     filePath: string;
 }
+export declare function loadAgentSkills(projectRoot?: string): SkillEntry[];
 export interface RenderAgentPromptOptions {
     layout?: LayoutSpec;
     session?: {
@@ -39,6 +49,12 @@ export interface RenderAgentPromptOptions {
     vars?: Record<string, unknown>;
     skills?: SkillEntry[];
     messages?: TemplateMessage[];
+    semanticContinuity?: SemanticContinuityContext;
+    threadState?: ConversationThreadState;
+    mcpAppProjections?: readonly McpAppStateDescriptor[];
+    mcpAppModelContext?: McpAppModelContext;
+    appLayoutSnapshot?: McpAppLayoutSnapshot;
+    mcpAppAvailable?: McpAppsContext['available'];
     threadId?: string;
 }
 export declare class Crewx extends TypedEventEmitter {
@@ -56,22 +72,34 @@ export declare class Crewx extends TypedEventEmitter {
     private readonly _activeAdapters;
     private readonly _pendingThreads;
     private readonly _activeTasks;
+    private readonly _activeInterceptorPids;
+    private readonly _interceptorRunTaskIds;
     private readonly _remoteFactory?;
+    private readonly _taskTicketIssuer?;
     private readonly _remoteTargets;
+    private readonly _detachedRemoteTargets;
     private readonly _additionalArgsProvider?;
+    private readonly _onRateLimitObserved?;
+    private _globalSettings?;
+    private readonly _callerIdentityOverrides;
     private constructor();
     private resolveFileRemoteTarget;
+    private _readRemoteTargetStat;
     private static loadBuiltInConfig;
     private static mergeCrewxConfig;
     static loadYaml(path: string | undefined, options?: CrewxOptions, fsAdapter?: IFsAdapter): Promise<Crewx>;
-    static fromConfig(config: CrewxProjectConfig, options?: CrewxOptions, projectRoot?: string, fsAdapter?: IFsAdapter): Promise<Crewx>;
+    static fromConfig(config: CrewxProjectConfig, options?: Omit<CrewxOptions, 'taskTicketIssuer'>, projectRoot?: string, fsAdapter?: IFsAdapter): Promise<Crewx>;
     get agents(): ReadonlyMap<string, AgentConfig>;
     get config(): CrewxProjectConfig | undefined;
     get plugins(): readonly CrewxPlugin[];
     get tools(): ReadonlyMap<string, ToolDefinition>;
+    listApps(options?: CrewxAppCatalogOptions): Promise<CrewxAppCatalogResult>;
+    listWorkspaceApps(options?: CrewxAppCatalogOptions): Promise<CrewxAppCatalogResult>;
     get workspaceId(): string;
+    createUiRuntime(options: UiRuntimeOptions): UiRuntimeFacade;
     get workspaceName(): string;
     getAgent(agentRef: string): AgentConfig | undefined;
+    canResumeSession(agentRef: string, params: CanResumeSessionParams): Promise<CanResumeSessionResult>;
     getRemoteProviderConfig(providerId: string): RemoteProviderConfig | undefined;
     private computeTaskLogPath;
     registerTool(name: string, definition: Omit<ToolDefinition, 'name'>): void;
@@ -90,6 +118,14 @@ export declare class Crewx extends TypedEventEmitter {
         team?: string;
         provider?: string;
     }): AgentConfig[];
+    private readonly _promptListProviders;
+    registerPromptListProvider(resolver: PromptListResolver): void;
+    static readAgentListSnapshot(options: {
+        cwd: string;
+        env: Record<string, string>;
+        configPath?: string;
+    }): AgentListSnapshot;
+    static createAgentListPromptResolver(configPath?: string): PromptListResolver;
     renderAgentPrompt(agentId: string): string;
     renderPrompt(template: string, context?: TemplateContext): Promise<string>;
     registerLayout(name: string, template: string | CustomLayoutDefinition): void;
@@ -98,16 +134,45 @@ export declare class Crewx extends TypedEventEmitter {
     private _resolveLayoutSpec;
     private _extractLayoutId;
     private _extractLayoutProps;
+    private _resolveLayoutContinuityCapability;
     private _getConversationProvider;
+    private _filterActivityLogByTaskIds;
     private _fetchHistoryMessages;
+    private _resolveFreshProvider;
+    private _resolveLocalServerRuntime;
+    private _readInputBudgetPercent;
+    private _resolveBudgetModel;
+    private _resolveContextMode;
+    private _buildInstructionOnlyResumeManifest;
+    private _buildInstructionOnlyContinuity;
+    private _prepareInstructionOnlyResumeWithBudget;
+    private _activityLogEntryCounts;
+    private _buildUnresolvedContextBudgetManifest;
+    private _buildResolvedContextBudgetManifest;
+    private _renderFreshPromptVariant;
+    private _prepareFreshPromptWithBudget;
+    private _prepareFreshPromptWithBudgetImpl;
+    private _recountFreshProviderInitialInput;
+    private _validateFreshProviderInitialInputBudget;
     private _resolveTimeout;
+    private _resolveIdleTimeout;
     private _lookupCliAdapter;
+    private _resolveEffectiveCost;
     private _resolveEffectiveCwd;
     private _buildFileRemoteOptions;
+    private _registerCallerIdentityOverride;
+    private _clearCallerIdentityOverride;
+    private _rewriteCallerFacingPayload;
+    protected emit<K extends CrewxEventName>(event: K, payload: CrewxEventPayload<K>): void;
     private emitToolEvents;
     private emitTaskLogEntries;
+    private emitInterceptorSteps;
+    private interceptorRunContext;
     private tryParseJson;
+    private _resolveRunAccount;
+    private _reportRateLimit;
     query(agentRef: string, message: string, options?: QueryOptions): Promise<QueryResult>;
+    testAgentInterceptors(agentRef: string, phase: InterceptorPhase, text: string): Promise<InterceptorLaneRun | undefined>;
     continueQuery(threadId: string, toolResults: Array<{
         toolCallId: string;
         result: unknown;

package/dist/facade/task-ticket.d.ts

@@ -0,0 +1,14 @@
+export interface TaskTicketRequest {
+    readonly taskId: string;
+    readonly agentId: string;
+    readonly threadId: string;
+    readonly workspaceId: string;
+    readonly runEpoch: number;
+}
+export interface TaskTicketGrant {
+    readonly ticket: string;
+    readonly endpoint: string;
+    readonly workspaceSlug: string;
+}
+export type TaskTicketIssuer = (request: TaskTicketRequest) => Promise<TaskTicketGrant | null>;
+export declare function resolveTaskTicketEnv(issuer: TaskTicketIssuer | undefined, request: TaskTicketRequest, parentEnv?: NodeJS.ProcessEnv): Promise<Record<string, string>>;

package/dist/highlight/thread-highlight-prompt.d.ts

@@ -0,0 +1,2 @@
+export declare const THREAD_HIGHLIGHT_PROMPT_INSTRUCTIONS: string;
+export declare const THREAD_HIGHLIGHT_CONSOLIDATION_PROMPT_INSTRUCTIONS: string;

package/dist/highlight/thread-highlighter.d.ts

@@ -0,0 +1,326 @@
+import { z } from 'zod';
+import type { ThreadHighlight } from '../schema/thread-history.js';
+import type { ProviderRuntime } from '../provider/bridge.js';
+import type { CreateThreadHighlightInput, ThreadHighlightRegenerationCandidate } from '../repository/thread-history.repository.js';
+export { THREAD_HIGHLIGHT_CONSOLIDATION_PROMPT_INSTRUCTIONS, THREAD_HIGHLIGHT_PROMPT_INSTRUCTIONS, } from './thread-highlight-prompt.js';
+export declare const THREAD_HIGHLIGHTER_AGENT_ID: "thread_highlighter";
+export declare const THREAD_HIGHLIGHTER_PROVIDER_ORDER: readonly ["cli/claude", "cli/opencode", "cli/copilot", "cli/codex"];
+export type ThreadHighlightProviderId = (typeof THREAD_HIGHLIGHTER_PROVIDER_ORDER)[number];
+export declare const MAX_THREAD_HIGHLIGHT_TURN_TEXT_LENGTH = 4000;
+export declare const MAX_THREAD_HIGHLIGHT_PROMPT_LENGTH = 32000;
+export declare const MAX_THREAD_HIGHLIGHTS_PER_RUN = 3;
+export declare const MAX_THREAD_HIGHLIGHTS_PER_THREAD = 10;
+export declare const MAX_THREAD_HIGHLIGHT_INPUT_TURNS = 100;
+export declare const MAX_THREAD_HIGHLIGHT_REGENERATION_CANDIDATES = 40;
+export declare const MAX_THREAD_HIGHLIGHT_ALREADY_RECORDED_COUNT = 20;
+export declare const MAX_THREAD_HIGHLIGHT_ALREADY_RECORDED_TEXT_LENGTH = 160;
+export declare const MAX_THREAD_HIGHLIGHT_ALREADY_RECORDED_TOTAL_LENGTH = 4000;
+export declare const ThreadHighlightItemSchema: z.ZodObject<{
+    kind: z.ZodEnum<["decision", "judgment", "issue", "result", "pivot"]>;
+    text: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    anchorTaskId: z.ZodString;
+    coversFromTaskId: z.ZodString;
+    coversToTaskId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    text: string;
+    kind: "result" | "decision" | "judgment" | "issue" | "pivot";
+    anchorTaskId: string;
+    coversFromTaskId: string;
+    coversToTaskId: string;
+}, {
+    text: string;
+    kind: "result" | "decision" | "judgment" | "issue" | "pivot";
+    anchorTaskId: string;
+    coversFromTaskId: string;
+    coversToTaskId: string;
+}>;
+export declare const ThreadHighlightResponseSchema: z.ZodObject<{
+    highlights: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["decision", "judgment", "issue", "result", "pivot"]>;
+        text: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        anchorTaskId: z.ZodString;
+        coversFromTaskId: z.ZodString;
+        coversToTaskId: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        text: string;
+        kind: "result" | "decision" | "judgment" | "issue" | "pivot";
+        anchorTaskId: string;
+        coversFromTaskId: string;
+        coversToTaskId: string;
+    }, {
+        text: string;
+        kind: "result" | "decision" | "judgment" | "issue" | "pivot";
+        anchorTaskId: string;
+        coversFromTaskId: string;
+        coversToTaskId: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    highlights: {
+        text: string;
+        kind: "result" | "decision" | "judgment" | "issue" | "pivot";
+        anchorTaskId: string;
+        coversFromTaskId: string;
+        coversToTaskId: string;
+    }[];
+}, {
+    highlights: {
+        text: string;
+        kind: "result" | "decision" | "judgment" | "issue" | "pivot";
+        anchorTaskId: string;
+        coversFromTaskId: string;
+        coversToTaskId: string;
+    }[];
+}>;
+export declare const ThreadHighlightConsolidationItemSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodEnum<["auto", "manual"]>>;
+    status: z.ZodOptional<z.ZodEnum<["active", "dismissed"]>>;
+    kind: z.ZodEnum<["decision", "judgment", "issue", "result", "pivot"]>;
+    text: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    anchorTaskId: z.ZodString;
+    coversFromTaskId: z.ZodString;
+    coversToTaskId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    text: string;
+    kind: "result" | "decision" | "judgment" | "issue" | "pivot";
+    anchorTaskId: string;
+    coversFromTaskId: string;
+    coversToTaskId: string;
+    id?: string | undefined;
+    status?: "active" | "dismissed" | undefined;
+    source?: "auto" | "manual" | undefined;
+}, {
+    text: string;
+    kind: "result" | "decision" | "judgment" | "issue" | "pivot";
+    anchorTaskId: string;
+    coversFromTaskId: string;
+    coversToTaskId: string;
+    id?: string | undefined;
+    status?: "active" | "dismissed" | undefined;
+    source?: "auto" | "manual" | undefined;
+}>;
+export declare const ThreadHighlightConsolidationResponseSchema: z.ZodObject<{
+    highlights: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodEnum<["auto", "manual"]>>;
+        status: z.ZodOptional<z.ZodEnum<["active", "dismissed"]>>;
+        kind: z.ZodEnum<["decision", "judgment", "issue", "result", "pivot"]>;
+        text: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        anchorTaskId: z.ZodString;
+        coversFromTaskId: z.ZodString;
+        coversToTaskId: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        text: string;
+        kind: "result" | "decision" | "judgment" | "issue" | "pivot";
+        anchorTaskId: string;
+        coversFromTaskId: string;
+        coversToTaskId: string;
+        id?: string | undefined;
+        status?: "active" | "dismissed" | undefined;
+        source?: "auto" | "manual" | undefined;
+    }, {
+        text: string;
+        kind: "result" | "decision" | "judgment" | "issue" | "pivot";
+        anchorTaskId: string;
+        coversFromTaskId: string;
+        coversToTaskId: string;
+        id?: string | undefined;
+        status?: "active" | "dismissed" | undefined;
+        source?: "auto" | "manual" | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    highlights: {
+        text: string;
+        kind: "result" | "decision" | "judgment" | "issue" | "pivot";
+        anchorTaskId: string;
+        coversFromTaskId: string;
+        coversToTaskId: string;
+        id?: string | undefined;
+        status?: "active" | "dismissed" | undefined;
+        source?: "auto" | "manual" | undefined;
+    }[];
+}, {
+    highlights: {
+        text: string;
+        kind: "result" | "decision" | "judgment" | "issue" | "pivot";
+        anchorTaskId: string;
+        coversFromTaskId: string;
+        coversToTaskId: string;
+        id?: string | undefined;
+        status?: "active" | "dismissed" | undefined;
+        source?: "auto" | "manual" | undefined;
+    }[];
+}>;
+export type ThreadHighlightItem = z.infer<typeof ThreadHighlightItemSchema>;
+export type ThreadHighlightResponse = z.infer<typeof ThreadHighlightResponseSchema>;
+export type ThreadHighlightConsolidationResponse = z.infer<typeof ThreadHighlightConsolidationResponseSchema>;
+export interface ThreadHighlightTaskTurn {
+    taskId?: string;
+    task_id?: string;
+    id?: string;
+    prompt: string;
+    result?: string | null;
+    response?: string | null;
+    status?: string | null;
+    startedAt?: string | null;
+    started_at?: string | null;
+    completedAt?: string | null;
+    completed_at?: string | null;
+}
+export interface ThreadHighlightAlreadyRecorded {
+    kind: ThreadHighlight['kind'];
+    text: string;
+}
+export interface ThreadHighlightGenerationInput {
+    threadId: string;
+    agentId?: string;
+    workspaceId?: string;
+    turns: readonly ThreadHighlightTaskTurn[];
+    alreadyRecorded?: readonly ThreadHighlightAlreadyRecorded[];
+    already_recorded?: readonly ThreadHighlightAlreadyRecorded[];
+    coversFromTaskId?: string;
+    coversToTaskId?: string;
+    covers_from_task_id?: string;
+    covers_to_task_id?: string;
+    detectorVersion?: string;
+    detector_version?: string;
+}
+export interface ThreadHighlightConsolidationItem {
+    id?: string | null;
+    source?: string | null;
+    status?: string | null;
+    kind: ThreadHighlight['kind'];
+    text: string | null;
+    anchorTaskId?: string | null;
+    coversFromTaskId?: string | null;
+    coversToTaskId?: string | null;
+    sourceTaskId?: string | null;
+    covers_from_task_id?: string | null;
+    covers_to_task_id?: string | null;
+    source_task_id?: string | null;
+    contentFingerprint?: string | null;
+    content_fingerprint?: string | null;
+}
+export interface ThreadHighlightConsolidationInput {
+    threadId?: string;
+    agentId?: string;
+    workspaceId?: string;
+    detectorVersion?: string;
+    detector_version?: string;
+    currentHighlights?: readonly ThreadHighlightConsolidationItem[];
+    currentAutoHighlights?: readonly ThreadHighlightConsolidationItem[];
+    current?: readonly ThreadHighlightConsolidationItem[];
+    existingHighlights?: readonly ThreadHighlightConsolidationItem[];
+    existingAutoHighlights?: readonly ThreadHighlightConsolidationItem[];
+    existing?: readonly ThreadHighlightConsolidationItem[];
+    newCandidates?: readonly ThreadHighlightConsolidationItem[];
+    candidates?: readonly ThreadHighlightConsolidationItem[];
+    newHighlights?: readonly ThreadHighlightConsolidationItem[];
+    manualHighlights?: readonly ThreadHighlightConsolidationItem[];
+    manual?: readonly ThreadHighlightConsolidationItem[];
+}
+export interface ThreadHighlightWriter {
+    resolveWorkspaceId?(threadId: string): string | null | Promise<string | null>;
+    createHighlight(input: CreateThreadHighlightInput): ThreadHighlight | Promise<ThreadHighlight>;
+}
+export interface ThreadHighlightGeneratorOptions {
+    repository: ThreadHighlightWriter;
+    workspaceId?: string;
+    providerFactory?: (provider: ThreadHighlightProviderId) => ProviderRuntime;
+    providers?: Partial<Record<ThreadHighlightProviderId, ProviderRuntime>>;
+}
+export interface ThreadHighlightBatchDetectorOptions {
+    providerFactory?: (provider: ThreadHighlightProviderId) => ProviderRuntime;
+    providers?: Partial<Record<ThreadHighlightProviderId, ProviderRuntime>>;
+}
+export interface ThreadHighlightConsolidationOptions {
+    providerFactory?: (provider: ThreadHighlightProviderId) => ProviderRuntime;
+    providers?: Partial<Record<ThreadHighlightProviderId, ProviderRuntime>>;
+}
+export type ThreadHighlightProviderAttemptOutcome = 'provider_error' | 'invalid_output';
+export interface ThreadHighlightProviderAttempt {
+    provider: ThreadHighlightProviderId;
+    outcome: ThreadHighlightProviderAttemptOutcome;
+    batchIndex?: number;
+}
+export type ThreadHighlightFailureCode = 'INVALID_INPUT' | 'PROVIDER_EXHAUSTED' | 'INVALID_OUTPUT' | 'REPOSITORY_FAILED' | 'THREAD_HIGHLIGHT_REGENERATION_NO_ELIGIBLE_TURNS' | 'THREAD_HIGHLIGHT_REGENERATION_DETECTION_FAILED';
+export interface ThreadHighlightGenerationFailure {
+    code: ThreadHighlightFailureCode;
+    message: string;
+    retryable: boolean;
+    attempts: readonly ThreadHighlightProviderAttempt[];
+}
+export interface ThreadHighlightGenerationSuccess {
+    ok: true;
+    provider: ThreadHighlightProviderId;
+    highlights: ThreadHighlight[];
+    attempts: readonly ThreadHighlightProviderAttempt[];
+}
+export interface ThreadHighlightGenerationFailureResult {
+    ok: false;
+    failure: ThreadHighlightGenerationFailure;
+}
+export type ThreadHighlightGenerationResult = ThreadHighlightGenerationSuccess | ThreadHighlightGenerationFailureResult;
+export interface ThreadHighlightRegenerationInput extends Omit<ThreadHighlightGenerationInput, 'turns'> {
+    turns: readonly ThreadHighlightTaskTurn[];
+}
+export interface ThreadHighlightBatchDetectionSuccess {
+    ok: true;
+    provider: ThreadHighlightProviderId;
+    candidates: readonly ThreadHighlightRegenerationCandidate[];
+    batchCount: number;
+    attempts: readonly ThreadHighlightProviderAttempt[];
+}
+export type ThreadHighlightBatchDetectionResult = ThreadHighlightBatchDetectionSuccess | ThreadHighlightGenerationFailureResult;
+export interface ThreadHighlightConsolidationHighlight extends ThreadHighlightRegenerationCandidate {
+    id?: string;
+    source: 'auto';
+    status: 'active';
+}
+export interface ThreadHighlightConsolidationSuccess {
+    ok: true;
+    provider: ThreadHighlightProviderId | null;
+    highlights: readonly ThreadHighlightConsolidationHighlight[];
+    candidates: readonly ThreadHighlightRegenerationCandidate[];
+    dismissedHighlightIds: readonly string[];
+    attempts: readonly ThreadHighlightProviderAttempt[];
+}
+export type ThreadHighlightConsolidationResult = ThreadHighlightConsolidationSuccess | ThreadHighlightGenerationFailureResult;
+export declare class ThreadHighlightGenerationError extends Error {
+    readonly failure: ThreadHighlightGenerationFailure;
+    readonly name = "ThreadHighlightGenerationError";
+    constructor(failure: ThreadHighlightGenerationFailure);
+}
+export declare class ThreadHighlightOutputValidationError extends Error {
+    readonly issuePaths: readonly string[];
+    readonly name = "ThreadHighlightOutputValidationError";
+    constructor(issuePaths: readonly string[]);
+}
+export declare class ThreadHighlightInputValidationError extends Error {
+    readonly field: string;
+    readonly name = "ThreadHighlightInputValidationError";
+    constructor(field: string);
+}
+export declare function redactThreadHighlightSecrets(value: string): string;
+export declare function buildThreadHighlightPrompt(input: ThreadHighlightGenerationInput): string;
+export declare function buildThreadHighlightConsolidationPrompt(input: ThreadHighlightConsolidationInput): string;
+export declare function parseThreadHighlightResponse(raw: unknown): ThreadHighlightResponse;
+export declare function parseThreadHighlightConsolidationResponse(raw: unknown): ThreadHighlightConsolidationResponse;
+export declare class ThreadHighlightGenerator {
+    private readonly repository;
+    private readonly workspaceId?;
+    private readonly providerFactory;
+    private readonly providers;
+    constructor(options: ThreadHighlightGeneratorOptions);
+    private detectBatch;
+    detectBatches(input: ThreadHighlightRegenerationInput): Promise<ThreadHighlightBatchDetectionResult>;
+    consolidate(input: ThreadHighlightConsolidationInput): Promise<ThreadHighlightConsolidationResult>;
+    consolidateHighlights(input: ThreadHighlightConsolidationInput): Promise<ThreadHighlightConsolidationResult>;
+    generate(input: ThreadHighlightGenerationInput): Promise<ThreadHighlightGenerationResult>;
+    generateOrThrow(input: ThreadHighlightGenerationInput): Promise<ThreadHighlightGenerationSuccess>;
+}
+export declare function generateThreadHighlights(input: ThreadHighlightGenerationInput, options: ThreadHighlightGeneratorOptions): Promise<ThreadHighlightGenerationResult>;
+export declare function consolidateThreadHighlights(input: ThreadHighlightConsolidationInput, options?: ThreadHighlightConsolidationOptions): Promise<ThreadHighlightConsolidationResult>;
+export declare function detectThreadHighlightBatches(input: ThreadHighlightRegenerationInput, options: ThreadHighlightBatchDetectorOptions): Promise<ThreadHighlightBatchDetectionResult>;
+export declare const generateThreadHighlightBatches: typeof detectThreadHighlightBatches;
+export declare const ThreadHighlighter: typeof ThreadHighlightGenerator;

package/dist/index.browser.d.ts

@@ -2,8 +2,32 @@ export { Crewx } from './facade/Crewx.browser.js';
 export type { ToolDefinition, BrowserQueryOptions, BrowserFromConfigOptions } from './facade/Crewx.browser.js';
 export { registerProviderFactory, createProvider, ProviderError } from './provider/bridge.browser.js';
 export type { ProviderRuntime, ProviderFactory, ProviderQueryOptions } from './provider/bridge.browser.js';
+export { classifyTaskError } from './provider/classify-task-error.js';
+export { redactTechnicalMessage } from './provider/redact-technical-message.js';
+export type { TaskErrorCode, TaskErrorMeta, TaskErrorProjection } from './provider/task-error.types.js';
 export { parseYamlContent, ConfigLoadError } from './config/loader.browser.js';
+export { normalizeClaudeMode } from './config/canonicalize-agent-options.js';
 export { BrowserFsAdapter } from './platform/BrowserFsAdapter.js';
 export type { IFsAdapter } from './platform/IFsAdapter.js';
 export { PROVIDER_ORDER, providerRank, compareProviders, normalizeProviderId } from './provider/order.js';
-export type { AgentConfig, CrewxProjectConfig, CrewxOptions, QueryOptions, QueryResult, ExecuteOptions, ExecuteResult, } from './types/index.js';
+export { ANTIGRAVITY_MODEL_COMPATIBILITY, CLAUDE_MODEL_COMPATIBILITY_PAIRS, CLAUDE_OPUS_4_8_BASE_MODEL_ID, CLAUDE_OPUS_4_8_LEGACY_MODEL_ID, resolveAntigravityModel, resolveCatalogModelId, resolveProviderCatalogModel, } from './config/model-compat.js';
+export type { AntigravityResolvedModel } from './config/model-compat.js';
+export { EFFORT_LEVELS, PROVIDER_ARGV_EFFORTS } from './config/models.generated.js';
+export type { EffortLevel, KnownEffortLevel } from './config/models.generated.js';
+export { getDefaultAgentProfile } from './config/default-agent-models.js';
+export type { DefaultAgentProfile, DefaultAgentStage } from './config/default-agent-models.js';
+export { BUILTIN_THREAD_STATES, THREAD_PRIORITIES, customStateLabel, hasThreadTitleKey, isThreadPriority, isThreadState, matchesThreadTitleFilter, mergeThreadTitleMeta, parseThreadPriorityFilter, parseThreadStateFilter, readThreadTitleMeta, threadTitleSearchHaystack, } from './repository/thread-title.types.js';
+export type { BuiltinThreadState, LegacyThreadState, StableThreadState, ThreadPriority, ThreadState, ThreadTitleFilter, ThreadTitleMeta, ThreadTitlePatch, } from './repository/thread-title.types.js';
+export type { AgentConfig, CrewxProjectConfig, CrewxOptions, QueryOptions, QueryResult, ExecuteOptions, ExecuteResult, ContextMode, } from './types/index.js';
+export { MCP_APP_HOST_TOOL_ALLOWLIST } from './mcp-app/types.js';
+export type { CrewxAppCapability, CrewxAppCatalogOptions, CrewxAppCatalogResult, CrewxAppDefinitionHashInput, CrewxAppDefinitionSummary, CrewxAppDiagnostic, CrewxAppDiagnosticCode, CrewxAppDiagnosticSource, CrewxAppInstalledProjection, CrewxAppLocalDefinitionRef, CrewxAppOrigin, CrewxAppOwnership, CrewxAppShareability, CrewxAppSharingAvailability, CrewxAppSummary, McpAppHostToolName, } from './mcp-app/types.js';
+export { UI_CONTENT_MEDIA_TYPES, buildMcpAppContentActions, contentActionsMatch, isMcpAppContentActions, isUiContentMediaType, isValidUiAppInstanceId, } from './mcp-app/content-declarations.js';
+export type { McpAppContentActionDeclaration, McpAppContentActions, UiContentMediaType, } from './mcp-app/content-declarations.js';
+export { APP_SCHEDULE_INERT_COMMAND, APP_SCHEDULE_INTERVALS_MINUTES, APP_SCHEDULE_MAX_PER_APP, APP_SCHEDULE_PERIODIC_REASONS, APP_SCHEDULE_TIMEOUT_MS, SCHEDULE_TRIGGERS, isAppSchedulePeriodicReason, isAppScheduleCode, isAppScheduleIntervalMinutes, isAppScheduleTimeoutMs, } from './app/schedule-contract.js';
+export type { AppScheduleDirective, AppScheduleIntervalMinutes, AppSchedulePeriodic, AppSchedulePeriodicReason, AppScheduleRunVerdict, AppScheduleSnapshot, AppScheduleStatus, ScheduleTrigger, ToolScheduleDeclaration, } from './app/schedule-contract.js';
+export { APP_JOB_CAPABILITY, APP_JOB_CAPABILITY_VERSION, APP_JOB_DEADLINE_MS, APP_JOB_MAX_PER_APP, APP_JOB_OPERATIONS, APP_JOB_OUTCOMES, APP_JOB_RUN_REQUIRED, APP_JOB_REFUSAL_CODES, APP_JOB_STATES, APP_JOB_STOP_REASONS, APP_JOB_TRIGGERS, hasAppJobCapability, isAppJobCode, isAppJobDeadlineMs, isAppJobOperation, isAppJobPhase, } from './app/job-contract.js';
+export type { AppJobCapabilityDeclaration, AppJobOperation, AppJobOutcome, AppJobRefusalCode, AppJobState, AppJobStopReason, AppJobTrigger, ToolJobDeclaration, } from './app/job-contract.js';
+export { APP_JOB_BRIDGE_DRAIN_TIMEOUT_MS, APP_JOB_BRIDGE_ENV, APP_JOB_BRIDGE_MAX_LINE_BYTES, APP_JOB_BRIDGE_REPLY_TIMEOUT_MS, APP_JOB_BRIDGE_VERSION, appJobTriggerForActor, parseAppJobView, } from './app/job-wire.js';
+export type { AppJobView, AppJobWireHandle } from './app/job-wire.js';
+export { CREWX_OPEN_APP_CAPABILITY, CREWX_OPEN_APP_CAPABILITY_VERSION, CREWX_OPEN_APP_MAX_JSON_DEPTH, CREWX_OPEN_APP_MAX_PARAMS_BYTES, CREWX_OPEN_APP_METHOD, CREWX_OPEN_APP_STATUS_METHOD, CREWX_OPEN_APP_SUCCESS_STATUSES, CrewxOpenAppError, UI_APP_OPEN_CAUSE_CODES, UI_APP_OPEN_ERROR_CODES, canonicalCrewxOpenAppPayload, createCrewxOpenAppCapabilityDeclaration, createCrewxOpenAppErrorResult, createCrewxOpenAppRequestId, createCrewxOpenAppSuccessResult, decideCrewxOpenAppOpen, decideCrewxOpenAppStatus, isSameCrewxOpenAppSourceBinding, parseCrewxOpenAppCapabilityDeclaration, parseCrewxOpenAppRequest, parseCrewxOpenAppResult, parseCrewxOpenAppStatusRequest, resolveCrewxOpenAppActionOutcome, } from './mcp-app/app-handoff.js';
+export type { CrewxOpenAppAction, CrewxOpenAppActionOutcome, CrewxOpenAppCapabilityDeclaration, CrewxOpenAppDecisionInput, CrewxOpenAppErrorResult, CrewxOpenAppIdempotencyDecision, CrewxOpenAppLedgerLookup, CrewxOpenAppLedgerRecord, CrewxOpenAppReceiptLookup, CrewxOpenAppRequest, CrewxOpenAppResult, CrewxOpenAppSourceBinding, CrewxOpenAppStatusRequest, CrewxOpenAppSuccessResult, CrewxOpenAppSuccessStatus, UiAppOpenCauseCode, UiAppOpenErrorCode, } from './mcp-app/app-handoff.js';