@modelprofile.com/flexharness 10.23.0 → 10.24.1

package/dist_ts/classes.flexharness.d.ts

@@ -1,62 +1,7 @@
 import type { IFlexBackgroundExecution, IFlexBeginSessionImportOptions, IFlexCompactSessionOptions, IFlexCreateProjectTaskInput, IFlexCreateSessionOptions, IFlexDeleteSessionGenerationCohortInput, IFlexDeleteSessionGenerationCohortResult, IFlexEventArchiveMetadata, IFlexHarnessOptions, IFlexImportedRun, IFlexMessage, IFlexMessagePage, IFlexMessagePageOptions, IFlexPermissionRequest, IFlexProjectGoalResult, IFlexSteerAdmission, IFlexSteerInput, IFlexProjectScratchpadResult, IFlexProjectStateResult, IFlexProjectTaskResult, IFlexProjectTasksResult, IFlexPromptAdmission, IFlexPromptQueueAdmission, IFlexPromptQueueEntry, IFlexPromptOptions, IFlexPromptResult, IFlexRedoSessionResult, IFlexScheduledPromptAdmission, IFlexSchedulePromptOptions, IFlexSession, IFlexSessionView, IFlexSessionMetrics, IFlexSessionImportHandle, IFlexSessionImportProgress, IFlexSessionReversionInfo, IFlexSlashCommandDescriptor, IFlexSlashCommandExecutionOptions, IFlexUncertainToolExecution, IFlexUndoSessionResult, IFlexUpdateSessionOptions, IFlexUpdateProjectTaskInput, IJsonObject, TFlexBeginSessionImportResult, TFlexHarnessEventListener, TFlexPermissionDecision, TFlexPrompt, TFlexSlashCommandExecutionResult, TFlexToolExecutionReconciliation } from './interfaces.js';
-export declare function createFlexResourceToolNamespace(resourceId: string, attachmentRevision: number): string;
-export declare function createFlexResourceToolName(namespace: string, toolName: string): string;
+export { createFlexResourceToolNamespace, createFlexResourceToolName, } from './utils.flexharness.js';
 export declare class FlexHarness<TScope = unknown> {
-    private readonly scopeResolver;
-    private readonly modelResolver;
-    private readonly sessionConfigurationResolver;
-    private readonly toolProvider;
-    private readonly resourceToolProviderResolver;
-    private readonly executionContextProvider;
-    private readonly delegatedRunAdmissionProvider;
-    private readonly stores;
-    private readonly agentSessionPolicy;
-    private readonly toolOutputLimits;
-    private readonly callbackLimits;
-    private readonly promptQueueLimits;
-    private readonly reversionLimits;
-    private readonly sessionImportLimits;
-    private readonly reversionMaintenanceTimeoutMs;
-    private readonly turnReversionProvider;
-    private readonly reversionPolicy;
-    private readonly externalErrorProjector?;
-    private readonly subagents;
-    private readonly builtInTools;
-    private readonly toolCatalogOptions;
-    private readonly slashCommands;
-    private readonly maxSubagentDepth;
-    private readonly maxSubagentCallsPerRun;
-    private readonly stateLoads;
-    private readonly sessionConfigurations;
-    private readonly scopeAdmissions;
-    private readonly scopeRetirements;
-    private readonly storageDrains;
-    private readonly storageCompactorLifecycleControllers;
-    private orphanedResourceQueue;
-    private readonly listeners;
-    private readonly trustedInternalErrors;
-    private readonly orphanedStoredSessions;
-    private readonly orphanedExecutionContexts;
-    private readonly orphanedProviderReleases;
-    private readonly orphanedTombstoneCleanups;
-    private readonly orphanedTombstoneOwners;
-    private readonly pendingPromptAdmissionOwners;
-    private readonly projectManagementQueues;
-    /** A session's result writes, one at a time: they share the session's index of results. */
-    private readonly resultQueues;
-    private readonly activeSlashCommandExecutions;
-    private readonly activeSlashCommandListings;
-    private readonly stagedSessionImports;
-    private readonly compactorInvocationContext;
-    private readonly slashCommandInvocationContext;
-    private readonly slashCommandActivityContext;
-    private readonly deferredCompactorContexts;
-    private sequence;
-    private promptQueueSequence;
-    private pendingPromptAdmissions;
-    private pendingPromptAdmissionBytes;
-    private closed;
-    private disposePromise?;
+    private readonly core;
     constructor(options: IFlexHarnessOptions<TScope>);
     listSessions(scopeId: string): Promise<IFlexSession[]>;
     createSession(scopeId: string, options?: IFlexCreateSessionOptions): Promise<IFlexSession>;
@@ -95,47 +40,19 @@ export declare class FlexHarness<TScope = unknown> {
     clearProjectScratchpad(scopeId: string, sessionId: string): Promise<IFlexProjectScratchpadResult>;
     deleteSessionGenerationCohort(scopeId: string, input: IFlexDeleteSessionGenerationCohortInput): Promise<IFlexDeleteSessionGenerationCohortResult>;
     deleteSession(scopeId: string, sessionId: string): Promise<void>;
-    private startSessionDeletion;
-    private startReservedSessionDeletion;
-    private registerSessionDeletion;
-    private assertAuthorizedSessionGenerationCohort;
-    private reserveLiveSessionDeletion;
-    private deleteSessionInternal;
-    private finishReservedSessionDeletion;
     /**
      * Reads the session's metadata, visible messages and pending permissions in one step, together
      * with the instance's event sequence they include. It waits until no queued projection or scope
      * write and no change that emits events for the session is in progress.
      */
     getSessionView(scopeId: string, sessionId: string): Promise<IFlexSessionView>;
-    /**
-     * Opens a section that changes what a view of the session shows and emits the events that
-     * describe the change. Closing is idempotent; close it once the events are emitted or the
-     * change is rolled back.
-     */
-    private openPublication;
     getMessages(scopeId: string, sessionId: string): Promise<IFlexMessage[]>;
     listMessagePage(scopeId: string, sessionId: string, options?: IFlexMessagePageOptions): Promise<IFlexMessagePage>;
     getMessage(scopeId: string, sessionId: string, messageId: string): Promise<IFlexMessage>;
-    private resolveSessionConfiguration;
-    private abortSessionConfigurations;
     listSlashCommands(scopeId: string, sessionId: string): Promise<IFlexSlashCommandDescriptor[]>;
-    private createSlashCommandDescriptors;
     executeSlashCommand(scopeId: string, sessionId: string, untouchedInput: string, options?: IFlexSlashCommandExecutionOptions): Promise<TFlexSlashCommandExecutionResult>;
     /** Resolves the exact session configuration before looking up custom commands. */
     executeSessionSlashCommand(scopeId: string, sessionId: string, untouchedInput: string, options?: IFlexSlashCommandExecutionOptions): Promise<TFlexSlashCommandExecutionResult>;
-    private executeSlashCommandInternal;
-    private isSessionAvailableForSlashCommand;
-    private slashCommandPromptUnavailableReason;
-    private slashCommandPromptAvailability;
-    private requireSlashCommandPromptAvailable;
-    private promptAdmissionByteSize;
-    private isSessionRuntimeIdle;
-    private slashCommandSessionKey;
-    private requireSessionAvailableForSlashCommand;
-    private trackSlashCommandExecution;
-    private trackSlashCommandListing;
-    private executeSlashCommandHandler;
     prompt(scopeId: string, sessionId: string, prompt: TFlexPrompt, options?: IFlexPromptOptions): Promise<IFlexPromptResult>;
     startPrompt(scopeId: string, sessionId: string, prompt: TFlexPrompt, options?: IFlexPromptOptions): Promise<IFlexPromptAdmission>;
     enqueuePrompt(scopeId: string, sessionId: string, prompt: TFlexPrompt, options?: IFlexPromptOptions): Promise<IFlexPromptQueueAdmission>;
@@ -156,11 +73,6 @@ export declare class FlexHarness<TScope = unknown> {
     steerPrompt(scopeId: string, sessionId: string, queueId: string, steer: IFlexSteerInput): Promise<IFlexSteerAdmission>;
     /** Sends follow-up input only to an exact running direct child owned by this parent run. */
     sendSubagentInput(scopeId: string, parentSessionId: string, parentRunId: string, taskId: string, steer: IFlexSteerInput): Promise<IFlexSteerAdmission>;
-    /** The shared synchronous admission point; neither entrypoint starts or resumes a run. */
-    private admitRunSteer;
-    private sendSubagentInputInRun;
-    /** Fences live ownership by exact runtime pointers and admission seeds all the way to root. */
-    private assertLiveSubagentOwnership;
     abort(scopeId: string, sessionId: string): Promise<boolean>;
     listPendingPermissions(scopeId: string, sessionId?: string): Promise<IFlexPermissionRequest[]>;
     respondToPermission(scopeId: string, sessionId: string, permissionId: string, decision: TFlexPermissionDecision): Promise<void>;
@@ -170,20 +82,8 @@ export declare class FlexHarness<TScope = unknown> {
         type: string;
     }): Promise<void>;
     compactSession(scopeId: string, sessionId: string, options?: IFlexCompactSessionOptions): Promise<void>;
-    private compactStoredSession;
     undoSession(scopeId: string, sessionId: string, signal?: AbortSignal): Promise<IFlexUndoSessionResult>;
     redoSession(scopeId: string, sessionId: string, signal?: AbortSignal): Promise<IFlexRedoSessionResult>;
-    private reversionUnit;
-    private reversionGroups;
-    private requireReversionIdle;
-    private reversionUnavailableReason;
-    private awaitReversionOperation;
-    private changeReversionCursor;
-    private changeReversionCursorResolved;
-    private reconcileContextAvailability;
-    private resumePendingApply;
-    private persistKnownNotApplied;
-    private recoverPendingCapture;
     archiveSessionEvents(scopeId: string, sessionId: string, compactionEventId?: string): Promise<IFlexEventArchiveMetadata | undefined>;
     listBackgroundExecutions(scopeId: string, sessionId: string): Promise<IFlexBackgroundExecution[]>;
     getBackgroundExecution(scopeId: string, sessionId: string, executionId: string): Promise<IFlexBackgroundExecution>;
@@ -191,339 +91,4 @@ export declare class FlexHarness<TScope = unknown> {
     subscribe(listener: TFlexHarnessEventListener): () => void;
     retireScope(scopeId: string): Promise<void>;
     dispose(): Promise<void>;
-    private enqueuePromptInternal;
-    private reservePendingPromptAdmission;
-    private schedulePromptQueueDrain;
-    private drainPromptQueue;
-    private createActiveRun;
-    private assertPromptPromotion;
-    private assertDelegatedRunAdmissionOwnership;
-    private acquireDelegatedRunAdmission;
-    private normalizeDelegatedRunAdmissionLease;
-    private requestDelegatedRunAdmissionClose;
-    private startDelegatedRunAdmissionCloseAttempt;
-    private closeRunDelegatedRunAdmission;
-    private promoteQueuedPrompt;
-    private projectPromptQueueEntry;
-    private promptQueueEntry;
-    private emitPromptQueueEvent;
-    private finishQueuedPrompt;
-    private cancelQueuedPrompt;
-    private cancelStoredPromptQueue;
-    private purgeStoredPromptQueue;
-    /**
-     * Holds the end of a run's generation until one more of its background subagents settles. The
-     * subagent commits its result to the generation before it settles, so the model takes the result
-     * in with another step instead of the run ending without it. The engine bounds the scoped
-     * wait from its observed dispatch and commits timer check-ins. Returns at once when none runs.
-     */
-    private awaitNextBackgroundSubagent;
-    private executeRun;
-    private finishFailedRun;
-    private requireProjectManagementTools;
-    private projectManagementKey;
-    private queueProjectManagementOperation;
-    private awaitProjectManagementOperations;
-    private resolveProjectManagementSession;
-    private assertProjectManagementSession;
-    private loadProjectManagementState;
-    private readProjectManagementState;
-    private mutateProjectManagementState;
-    private projectStateResult;
-    private createSubagentProvenance;
-    private createProjectManagementSessionContext;
-    private projectTaskResult;
-    private projectTasksResult;
-    private projectGoalResult;
-    private projectScratchpadResult;
-    private createProjectTaskInState;
-    private updateProjectTaskInState;
-    private deleteProjectTaskInState;
-    private clearProjectTasksInState;
-    private setProjectGoalInState;
-    private clearProjectGoalInState;
-    private setProjectScratchpadInState;
-    private appendProjectScratchpadInState;
-    private clearProjectScratchpadInState;
-    private prepareGeneration;
-    /**
-     * The output the model gets: the output itself within the output budget, or, in a run with a
-     * catalog whose stores keep results, a handle to the stored output with a summary of it.
-     */
-    private budgetOutput;
-    private resultQueueKey;
-    /** The JSON bytes of one `results.get` page: the output budget, less room for the page's fields. */
-    private resultPageBytes;
-    /** One page of a stored result of the run's session, or the error `results.get` reports. */
-    private readResult;
-    /**
-     * Whether a call of the run's tools only reads: search_tools and describe_tools, an `execute` of
-     * a method declared read-only, or a call the tool handle classifies as read-only by its real name.
-     */
-    private isReadOnlyToolCall;
-    /** The method's path when the prepared call only reads, for the turn's reads. */
-    private readOnlyMethod;
-    /** A method whose `onCall` decides its calls is gated: its calls run in order, whatever they read. */
-    private isReadOnlyCatalogCall;
-    private classifyHostToolCall;
-    /**
-     * Runs the run's tools through the turn's reads: a read-only call identical to an earlier read of
-     * the turn shares its output, and any other call clears them. Records the confirmation of each
-     * call that started while the model still streamed, which the permission requests naming the
-     * call wait for. The catalog's tools read and run their methods by real name themselves.
-     */
-    private trackToolCalls;
-    /**
-     * Answers a read-only call (`name` set) from an identical read earlier in the turn, sharing the
-     * output of one still running, or runs it and keeps its output for the reads after it. A failed
-     * read, and a read whose response was discarded, are not kept. Any other call clears the turn's
-     * reads before it runs.
-     */
-    private readOnce;
-    private enabledBuiltInToolNames;
-    private assertNoBuiltInToolCollisions;
-    /**
-     * search_tools, describe_tools and execute. `execute` validates the call and runs the method
-     * inside this tool call, so the tool wrapper bounds its output and projects its errors, and the
-     * call's part, events and permission requests carry the method's path.
-     */
-    private createCatalogTools;
-    /** A refused catalog call as the trusted error the model and the tool part show. */
-    private catalogCallError;
-    /**
-     * Runs a `run_code` program. Every catalog call it makes is dispatched like an `execute`
-     * (validation, `onCall`, the method's run with its permission requests, the output limits, error
-     * projection) and recorded as a tool part of its own, named by the method, with the `run_code`
-     * call as its parent. Proposals go to `onProposals` as one batch once the program finished; a
-     * program that fails proposes nothing.
-     */
-    private runCatalogProgram;
-    private createBuiltInTools;
-    private createRenameSessionTool;
-    private createProjectTaskTool;
-    private createProjectGoalTool;
-    private createProjectScratchpadTool;
-    private projectManagementAgentWriteContext;
-    private executeProjectTaskTool;
-    private executeProjectGoalTool;
-    private executeProjectScratchpadTool;
-    private createProjectTaskId;
-    private createSubagentTool;
-    private executeSubagentTask;
-    private createSubagentSendTool;
-    private createSubagentResultTool;
-    private createDelegatedRunAdmissionSeed;
-    private acquireSubagentSession;
-    private createSubagentSessionId;
-    private updateSubagentToolPart;
-    private abortExactRun;
-    private createReservation;
-    private userMessageParts;
-    /**
-     * Ends steering intake once the run's generation has settled and fixes what became of its
-     * steers. A run that stays in the model context reports the steers its generation did not
-     * record; a run that does not, because it failed, was stopped before any model output or its
-     * outcome could not be established, reports every steer it accepted, since the model context
-     * of later turns holds none of them. The bytes of the steers not taken in are released.
-     */
-    private closeRunSteering;
-    /**
-     * Projects a steer the run's generation took in as a user message of the run. The assistant
-     * message that answered before it is completed and the run answers on in a new one; a steer
-     * taken in before the run answered anything is placed before its still empty assistant message.
-     */
-    private applyRunSteer;
-    private buildTerminal;
-    private reversionId;
-    private reversionProviderProtocolVersion;
-    private reversionCaptureContext;
-    private withReversionMaintenanceSignal;
-    private inspectReversionCapture;
-    private finalizeReversionCapture;
-    private resolveReversionCaptureOutcome;
-    private normalizeReversionReference;
-    private normalizeReversionOutcome;
-    private normalizeAffectedWorkspaces;
-    private prepareRunReversion;
-    private finalizeRunReversion;
-    private applyFinalizedReversionOutcome;
-    private hiddenReversionSegments;
-    private enqueueReversionRelease;
-    private enqueueReversionReleaseReference;
-    private pruneReversionState;
-    private commitRevertedBranch;
-    private commitRevertedBranchState;
-    private commitArchivedHiddenBranchState;
-    private refreshAutomaticArchiveHorizon;
-    private filterReversionContextEvents;
-    private drainReversionReleases;
-    private releaseDeletedSessionReversions;
-    private promoteCompletedTerminal;
-    private publishFailedTerminal;
-    private replaceStagedTerminal;
-    /**
-     * Puts a run's terminal messages in place of their projected versions: its prompt, and its last
-     * assistant message. The steers a run took in, and the assistant messages it completed before
-     * them, stay where they are. A terminal message that is not projected yet is added: the prompt
-     * before the run's other messages, the assistant message after them.
-     */
-    private replaceVisibleRun;
-    private emitTerminalProjection;
-    /**
-     * Ends a run that fails without publishing a terminal projection, because its namespace was
-     * fenced or retired or its durable outcome could not be established: listeners still receive
-     * its terminal message events and its one `run.finished`. Nothing here is persisted; the next
-     * load of the namespace repairs the stored projection from the canonical outcome.
-     */
-    private emitUnpublishedRunFinish;
-    private emitFinalRunEvent;
-    private onTextDelta;
-    private onReasoningStart;
-    private onReasoningDelta;
-    private onReasoningEnd;
-    private textAppendAccounting;
-    private onToolStart;
-    private onToolFinish;
-    private onToolUpdate;
-    private onRetry;
-    /**
-     * Emits the usage of every model call and adds reported usage to its run. A run executes a
-     * transactional generation, and `AgentSession.generate()` settles a transactional generation only
-     * after it has reported each of its model calls, also when it is aborted. `executeRun()` awaits
-     * that settlement before it builds the terminal, so the run is still active for each of its
-     * events: they all reach `run.usage` and precede its `run.finished`. The events bypass the
-     * callback limits and a failed callback: their number is bounded by the run's model calls, and
-     * the usage of a run that exhausted its callback budget or failed in a callback must not be lost.
-     */
-    private onModelCallUsage;
-    private settleMetricsOperation;
-    private callbackRun;
-    private reserveCallbackCapacity;
-    private failCallback;
-    private requestPermission;
-    private decideSessionPermissionPolicy;
-    private applyPermissionResponse;
-    private rollbackRememberedGrant;
-    private reconcileRememberedPermissionRemoval;
-    private rejectRunPermissions;
-    private rejectPending;
-    private forceRejectPending;
-    private cancelRun;
-    private abortRunInternally;
-    private rollbackAdmission;
-    private normalizeToolHandle;
-    private provideRunToolHandle;
-    private normalizeResourceToolProviderDescriptors;
-    private closePartialToolHandle;
-    private retainDetachedCleanup;
-    private observeDetachedToolProvider;
-    private trackDetachedCleanup;
-    private runDetachedCleanup;
-    private beginDetachedCleanupSettlement;
-    private settleDetachedCleanups;
-    private delegatedRunAdmissionOwnersForGeneration;
-    private settleDelegatedRunAdmissionOwners;
-    private projectExternalError;
-    private projectOperationError;
-    private trustInternalError;
-    private canonicalOutcomes;
-    private durableCanonicalOutcomes;
-    private loadState;
-    private createUninitializedStoredSession;
-    private loadSessionRuntime;
-    private repairLoadedSession;
-    private repairTerminal;
-    private withScopeMutationOwnership;
-    private mutateScope;
-    private mutateScopeOwned;
-    private mutateProjection;
-    private mutatePermissions;
-    private createScopeSnapshot;
-    private createProjectionSnapshot;
-    private upgradeProjectionSnapshot;
-    private reconcileProjectionFromStore;
-    private cleanupSessionDomains;
-    private tombstoneProjectManagementSession;
-    private collectSessionSubtree;
-    private tombstoneGroup;
-    private tombstonesForRoots;
-    private descendantTombstoneRoots;
-    private orderTombstoneRootsChildFirst;
-    private finishTombstoneCleanup;
-    private finishTombstoneCleanupInternal;
-    private fenceNamespace;
-    private deferNamespaceDrain;
-    private deferReversionReleaseDrain;
-    private sessionsAreDependencyRelated;
-    private isSessionAncestor;
-    private sessionAncestryDepth;
-    private sessionParentSessionId;
-    private sessionMetadata;
-    private closeStoredSession;
-    private abortStoredSession;
-    private storedSessionCleanupCompleted;
-    private releasePartialProviderSession;
-    private retainPartialProviderSession;
-    private hasOrphanedSessionResources;
-    private retainOrphanedTombstoneCleanup;
-    private closeOrphanedResources;
-    private closeOrphanedResourcesInternal;
-    private orphanedResourceStorageKeys;
-    private retireScopeInternal;
-    private drainStorage;
-    private drainStorageInternal;
-    private disposeInternal;
-    private abortSlashCommandExecutions;
-    private abortSlashCommandListings;
-    private appendUnexpectedErrors;
-    private abortCompactorLifecycle;
-    private resolveState;
-    private getScopeAdmission;
-    private pruneScopeAdmission;
-    private createScopeRetirementError;
-    private ambientSlashCommandOwner;
-    private assertNoAmbientSlashCommandTeardown;
-    private assertStateAcceptingWork;
-    private createCompactorContext;
-    /**
-     * The model the compacted work was dispatched on: the resolved model of the run whose context
-     * overflowed, or the model hint a manual compaction was requested with. Retention states none.
-     */
-    private compactionModel;
-    private withCompactorContext;
-    private createRunCompactorContext;
-    private effectiveRunCompactorContext;
-    private withRunCompactorContext;
-    private requireSession;
-    private completedReversionCandidates;
-    private visibleMessages;
-    private requireMutableSession;
-    /** Refuses an operation that would change an imported session's history or model context. */
-    private assertSessionWritable;
-    /** An imported session never ran here, so it has no hidden stage and no reversion state. */
-    private assertImportedSessionState;
-    private assertNoCommittingSessionImport;
-    private findStagedSessionImport;
-    private requireStagedSessionImport;
-    private armStagedImportIdleTimer;
-    private clearStagedImportIdleTimer;
-    private releaseStagedSessionImport;
-    /**
-     * An imported child session belongs to a committed imported parent whose run `parent.runId` holds
-     * the tool call `parent.toolCallId` naming the child, and no other session claims that tool call.
-     */
-    private requireImportParent;
-    private requireMessage;
-    private isTombstoned;
-    private emitPartEvent;
-    private emitPartDeltaEvent;
-    private partEventCoordinates;
-    private emitEvent;
-    private validateRuntimeEvent;
-    private projectBackgroundExecution;
-    private boundedIdentifier;
-    private messageCursorNamespace;
-    private createMessageCursor;
-    private parseMessageCursor;
-    private assertOpen;
 }

package/dist_ts/classes.flexharness.deletion.d.ts

@@ -0,0 +1,31 @@
+import type { IFlexDeleteSessionGenerationCohortInput, IFlexDeleteSessionGenerationCohortResult, IFlexSessionTombstone } from './interfaces.js';
+import type { IStorageState } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/**
+ * Session deletion: reservations, subtree tombstones and the cleanup of every domain a session
+ * owns.
+ */
+export declare class FlexHarnessSessionDeletion<TScope> {
+    private readonly core;
+    constructor(core: FlexHarnessCore<TScope>);
+    deleteSessionGenerationCohort(scopeId: string, input: IFlexDeleteSessionGenerationCohortInput): Promise<IFlexDeleteSessionGenerationCohortResult>;
+    deleteSession(scopeId: string, sessionId: string): Promise<void>;
+    private startSessionDeletion;
+    private startReservedSessionDeletion;
+    private registerSessionDeletion;
+    private assertAuthorizedSessionGenerationCohort;
+    private reserveLiveSessionDeletion;
+    deleteSessionInternal(state: IStorageState, scopeId: string, scope: TScope, sessionId: string): Promise<void>;
+    private finishReservedSessionDeletion;
+    cleanupSessionDomains(state: IStorageState, tombstone: IFlexSessionTombstone): Promise<void>;
+    private collectSessionSubtree;
+    tombstoneGroup(state: IStorageState, rootSessionId: string): IFlexSessionTombstone[];
+    private tombstonesForRoots;
+    descendantTombstoneRoots(state: IStorageState, ancestorSessionId: string): string[];
+    orderTombstoneRootsChildFirst(state: IStorageState, rootSessionIds: readonly string[]): string[];
+    finishTombstoneCleanup(state: IStorageState, rootSessionId: string, scopeId: string, invocation?: {
+        scopeId: string;
+        scope: TScope;
+    }): Promise<void>;
+    private finishTombstoneCleanupInternal;
+}