@crewx/sdk 0.9.0-rc.22 → 0.9.0-rc.220

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,8 +49,42 @@ 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;
 }
+interface ProviderSlotEffortResolution {
+    effort?: string;
+    fallback?: {
+        requested: string;
+        applied: string | null;
+        source: 'model-default' | 'provider-default' | 'dropped';
+    };
+}
+type EffortSource = 'boost' | 'route' | 'agent' | 'request' | 'model-default';
+type EffortDropReason = 'route-rule' | 'unsupported-by-model';
+interface EffortMetadataResolution {
+    effort?: string;
+    source: EffortSource;
+    dropped?: {
+        requested: string;
+        reason: EffortDropReason;
+    };
+}
+export declare function resolveEffortSelection(params: {
+    routeSelected: boolean;
+    boostEffort?: string;
+    routeEffort?: string;
+    requestEffort?: string;
+    agentEffort?: string;
+    ignoredAgentEffort?: string;
+    agentFallback?: ProviderSlotEffortResolution['fallback'];
+    supportedEfforts?: readonly string[];
+}): EffortMetadataResolution;
 export declare class Crewx extends TypedEventEmitter {
     private readonly _agents;
     private readonly _templateEngine;
@@ -56,22 +100,35 @@ 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 _routeDecisionService;
+    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 +147,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,19 +163,56 @@ 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 _planFreshHistorySnapshot;
+    private _writeAndVerifyHistorySnapshot;
+    private _resolveContextMode;
+    private _buildInstructionOnlyResumeManifest;
+    private _buildInstructionOnlyContinuity;
+    private _prepareInstructionOnlyResumeWithBudget;
+    private _activityLogEntryCounts;
+    private _byteBudgetActivityEntryCounts;
+    private _buildUnresolvedContextBudgetManifest;
+    private _prepareUnresolvedFreshPromptWithByteBudget;
+    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;
+    private _routeRunMetadata;
+    private _emitRouteDecisionActivity;
+    private _recordRoutedQuotaFailure;
     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;
     }>): Promise<QueryResult>;
     execute(agentRef: string, message: string, options?: ExecuteOptions): Promise<ExecuteResult>;
 }
+export {};

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/history-snapshot/index.d.ts

@@ -0,0 +1,83 @@
+import type { ConversationHighlight, TemplateMessage } from '../conversation/types.js';
+export type HistoryEntryKind = 'message' | 'activity' | 'highlight';
+export interface HistorySnapshotScope {
+    readonly workspaceRealPath: string;
+    readonly agentId: string;
+    readonly threadId: string;
+    readonly taskId: string;
+}
+export type HistoryActivityCoverage = Readonly<Record<string, unknown>>;
+export interface HistorySnapshotInput {
+    readonly scope: HistorySnapshotScope;
+    readonly runEpoch: number;
+    readonly preparedAtMs: number;
+    readonly messages: readonly TemplateMessage[];
+    readonly activityByTask: ReadonlyMap<string, string>;
+    readonly highlights: readonly ConversationHighlight[];
+    readonly activityCoverage?: HistoryActivityCoverage;
+}
+export interface HistorySnapshotPlan {
+    readonly ref: string;
+    readonly expiresAtMs: number;
+    readonly bytes: Buffer;
+}
+export interface HistorySnapshotRef {
+    readonly ref: string;
+    readonly entries: number;
+    readonly bytes: number;
+    readonly expiresAtMs: number;
+}
+export type HistorySnapshotErrorCode = 'INVALID_REF' | 'NOT_FOUND' | 'EXPIRED' | 'SCOPE_MISMATCH' | 'IDENTITY_MISSING' | 'TAMPERED' | 'UNSAFE_FILE' | 'TOO_LARGE' | 'IO_ERROR';
+export declare class HistorySnapshotError extends Error {
+    readonly code: HistorySnapshotErrorCode;
+    constructor(code: HistorySnapshotErrorCode);
+}
+export type HistoryOperation = 'toc' | 'search' | 'read';
+export interface HistoryEmissionRange {
+    readonly entry: number;
+    readonly startByte: number;
+    readonly endByte: number;
+}
+export interface HistoryPage {
+    readonly text: string;
+    readonly nextCommand?: string;
+    readonly snapshotRef: string;
+    readonly operation: HistoryOperation;
+    readonly entries: readonly number[];
+    readonly ranges: readonly HistoryEmissionRange[];
+    readonly byteCount: number;
+}
+export interface HistoryAuditRecord {
+    readonly version: 1;
+    readonly timestampMs: number;
+    readonly operation: HistoryOperation;
+    readonly taskId: string;
+    readonly entries: readonly number[];
+    readonly ranges: readonly HistoryEmissionRange[];
+    readonly byteCount: number;
+}
+export declare const MAX_PAGE_BYTES = 8000;
+export declare const MAX_PAGE_LINES = 1000;
+export declare const MAX_SNAPSHOT_BYTES: number;
+export declare const MAX_AUDIT_BYTES: number;
+export declare const MAX_AUDIT_RECORD_BYTES = 512;
+export declare function planHistorySnapshot(input: HistorySnapshotInput): HistorySnapshotPlan;
+export declare function writeHistorySnapshot(projectRoot: string, plan: HistorySnapshotPlan): Promise<HistorySnapshotRef>;
+export declare function scopeFromEnv(env: NodeJS.ProcessEnv, workspaceRealPath: string): HistorySnapshotScope;
+export declare function tocHistory(projectRoot: string, ref: string, scope: HistorySnapshotScope, options?: {
+    readonly from?: number;
+    readonly limit?: number;
+}): Promise<HistoryPage>;
+export declare function searchHistory(projectRoot: string, ref: string, scope: HistorySnapshotScope, options: {
+    readonly query: string;
+    readonly limit?: number;
+    readonly cursor?: string;
+}): Promise<HistoryPage>;
+export declare function readHistory(projectRoot: string, ref: string, scope: HistorySnapshotScope, options: {
+    readonly entry: number;
+    readonly offset?: number;
+    readonly bytes?: number;
+}): Promise<HistoryPage>;
+export declare function recordHistoryEmission(projectRoot: string, ref: string, scope: HistorySnapshotScope, page: HistoryPage): Promise<void>;
+export declare function readHistoryAudit(projectRoot: string, ref: string, scope: HistorySnapshotScope): Promise<readonly HistoryAuditRecord[]>;
+export declare function resolveWorkspaceRealPathSync(path: string): string;