@modelprofile.com/flexharness 2.0.0 → 3.0.0

package/changelog.md

@@ -0,0 +1,57 @@
+# Changelog
+
+## 2026-08-09 - 3.0.0
+
+### Breaking Changes
+
+- migrate runtime to AgentSession-backed split stores (harness)
+  - Replaces the single legacy store and runner integration with domain-specific stores for scopes, projections, permissions, Agent events, and tool jobs.
+  - Adds scheduled prompts, runtime event APIs, uncertain tool-execution reconciliation, session compaction/archive support, and background execution controls.
+  - Introduces durable staged terminal recovery, session tombstones, retryable cleanup ownership, commit-uncertain store errors, and JSON store fsync/disposal handling.
+  - Adds a 2.x legacy snapshot migration export and updates documentation and tests for the 3.x persistence model.
+
+## 2026-08-08 - 2.1.0
+
+### Features
+
+- add storage namespace retirement (harness)
+  - Add retireScope() to stop runtime ownership for resolved storage namespaces without deleting durable snapshots.
+  - Fence stale scope resolution and late admissions while draining in-flight persistence, permissions, active runs, and tool cleanup.
+  - Coalesce retirement and disposal drains by storage namespace and preserve isolated cleanup error reporting.
+  - Document retirement behavior and add lifecycle/resolver tests for concurrency and cleanup paths.
+
+## 2026-08-07 - 2.0.0
+
+### Breaking Changes
+
+- project external run errors and add durable prompt/message APIs (harness)
+  - Convert untrusted resolver, runner, tool, cleanup, callback, and run-persistence failures to FlexHarnessExternalError before exposing them through completions, audit data, events, or disposal.
+  - Add externalErrorProjector support for application-approved external error projection.
+  - Add startPrompt() admission semantics plus cursor-based message paging and exact message lookup APIs.
+  - Add optional resolved model variant metadata and validate it in persisted/public message data.
+  - Harden permission rollback so failed persistence cannot leave remembered grants reusable.
+
+## 2026-08-05 - 1.0.1
+
+### Fixes
+
+- publish JSON Schema typings required by public model types (deps)
+  - Move @types/json-schema from devDependencies to dependencies so downstream consumers can resolve exported declaration types.
+
+## 2026-08-05 - 1.0.0
+
+### Breaking Changes
+
+- Establish the initial 1.0 public API for provider-neutral model sessions.
+- Persist successful-only private model history while keeping failed and cancelled prompts audit-visible.
+- Redact attachment payloads from public messages and events, exposing metadata only.
+- Add revisioned transactional stores, session-scoped permissions, typed immutable events, and explicit lifecycle cleanup.
+- Add minimal session title, archive, and deletion mutations with active-run safety.
+- Coordinate resolver failure without hanging on an unresponsive sibling and close detached late tool handles.
+- Coalesce model callbacks in a bounded run-local buffer instead of persisting every delta.
+- Distinguish owner cancellation from internal failure and require successful tool cleanup before appending history.
+- Terminalize in-memory audit state and emit terminal events once when final persistence fails.
+- Enforce JSON output byte limits incrementally while traversing large values.
+- Linearize cancellation at terminal persistence and keep disposal waiting for committing runs.
+- Serialize permission checks behind persistence so uncommitted remembered grants are never observable.
+- Track detached tool-provider cleanup through disposal and report late close failures.

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@modelprofile.com/flexharness',
-    version: '2.0.0',
+    version: '3.0.0',
     description: 'Provider-neutral model-session runtime with durable history, permissions, typed events, and pluggable local or remote tool execution.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSwrQkFBK0I7SUFDckMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHVJQUF1STtDQUNySixDQUFBIn0=

package/dist_ts/classes.flexharness.d.ts

@@ -1,18 +1,24 @@
-import type { IFlexCreateSessionOptions, IFlexHarnessOptions, IFlexMessage, IFlexMessagePage, IFlexMessagePageOptions, IFlexPermissionRequest, IFlexPromptOptions, IFlexPromptAdmission, IFlexPromptResult, IFlexSession, IFlexUpdateSessionOptions, TFlexHarnessEventListener, TFlexPermissionDecision, TFlexPrompt } from './interfaces.js';
+import type { IFlexBackgroundExecution, IFlexCreateSessionOptions, IFlexEventArchiveMetadata, IFlexHarnessOptions, IFlexMessage, IFlexMessagePage, IFlexMessagePageOptions, IFlexPermissionRequest, IFlexPromptAdmission, IFlexPromptOptions, IFlexPromptResult, IFlexScheduledPromptAdmission, IFlexSchedulePromptOptions, IFlexSession, IFlexUncertainToolExecution, IFlexUpdateSessionOptions, IJsonObject, TFlexHarnessEventListener, TFlexPermissionDecision, TFlexPrompt, TFlexToolExecutionReconciliation } from './interfaces.js';
 export declare class FlexHarness<TScope = unknown> {
     private readonly scopeResolver;
     private readonly modelResolver;
     private readonly toolProvider;
-    private readonly store;
-    private readonly runner;
+    private readonly executionContextProvider;
+    private readonly stores;
+    private readonly agentSessionPolicy;
     private readonly toolOutputLimits;
     private readonly callbackLimits;
     private readonly externalErrorProjector?;
     private readonly stateLoads;
+    private readonly scopeAdmissions;
+    private readonly scopeRetirements;
+    private readonly storageDrains;
+    private orphanedResourceQueue;
     private readonly listeners;
-    private readonly detachedToolCleanups;
-    private readonly detachedToolCleanupErrors;
     private readonly trustedInternalErrors;
+    private readonly orphanedStoredSessions;
+    private readonly orphanedExecutionContexts;
+    private readonly orphanedProviderReleases;
     private sequence;
     private closed;
     private disposePromise?;
@@ -22,22 +28,41 @@ export declare class FlexHarness<TScope = unknown> {
     getSession(scopeId: string, sessionId: string): Promise<IFlexSession>;
     updateSession(scopeId: string, sessionId: string, options: IFlexUpdateSessionOptions): Promise<IFlexSession>;
     deleteSession(scopeId: string, sessionId: string): Promise<void>;
+    private deleteSessionInternal;
     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>;
     prompt(scopeId: string, sessionId: string, prompt: TFlexPrompt, options?: IFlexPromptOptions): Promise<IFlexPromptResult>;
     startPrompt(scopeId: string, sessionId: string, prompt: TFlexPrompt, options?: IFlexPromptOptions): Promise<IFlexPromptAdmission>;
-    abort(scopeId: string, sessionId: string, _reason?: string): Promise<boolean>;
+    schedulePrompt(scopeId: string, sessionId: string, scheduleKey: string, prompt: TFlexPrompt, options?: IFlexSchedulePromptOptions): Promise<IFlexScheduledPromptAdmission>;
+    cancelScheduledPrompt(scopeId: string, sessionId: string, scheduleKey: string): Promise<boolean>;
+    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>;
+    listUncertainToolExecutions(scopeId: string, sessionId: string): Promise<IFlexUncertainToolExecution[]>;
+    reconcileToolExecution(scopeId: string, sessionId: string, intentId: string, reconciliation: TFlexToolExecutionReconciliation): Promise<void>;
+    pushRuntimeEvent(scopeId: string, sessionId: string, event: IJsonObject & {
+        type: string;
+    }): Promise<void>;
+    compactSession(scopeId: string, sessionId: string): Promise<void>;
+    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>;
+    abortBackgroundExecution(scopeId: string, sessionId: string, executionId: string): Promise<void>;
     subscribe(listener: TFlexHarnessEventListener): () => void;
+    retireScope(scopeId: string): Promise<void>;
     dispose(): Promise<void>;
-    private disposeInternal;
+    private admitPrompt;
     private executeRun;
-    private reserveRun;
-    private finalizeRun;
-    private applyRunFinalState;
-    private emitFinalMutationEvents;
+    private finishFailedRun;
+    private prepareGeneration;
+    private createReservation;
+    private buildTerminal;
+    private promoteCompletedTerminal;
+    private publishFailedTerminal;
+    private replaceStagedTerminal;
+    private replaceVisibleRun;
+    private emitTerminalProjection;
     private emitFinalRunEvent;
     private onTextDelta;
     private onReasoningStart;
@@ -45,32 +70,76 @@ export declare class FlexHarness<TScope = unknown> {
     private onReasoningEnd;
     private onToolStart;
     private onToolFinish;
+    private callbackRun;
     private reserveCallbackCapacity;
+    private failCallback;
     private requestPermission;
     private applyPermissionResponse;
+    private rollbackRememberedGrant;
+    private reconcileRememberedPermissionRemoval;
     private rejectRunPermissions;
     private rejectPending;
     private forceRejectPending;
-    private emitPartEvent;
+    private cancelRun;
     private abortRunInternally;
-    private projectExternalError;
-    private trustInternalError;
+    private rollbackAdmission;
     private normalizeToolHandle;
-    private trackDetachedToolCleanup;
+    private closePartialToolHandle;
+    private retainDetachedCleanup;
     private observeDetachedToolProvider;
-    private emitEvent;
-    private resolveState;
+    private trackDetachedCleanup;
+    private runDetachedCleanup;
+    private beginDetachedCleanupSettlement;
+    private settleDetachedCleanups;
+    private projectExternalError;
+    private projectOperationError;
+    private trustInternalError;
+    private canonicalOutcomes;
+    private durableCanonicalOutcomes;
     private loadState;
-    private mutateAndSave;
-    private restorePersistentState;
-    private createSnapshot;
+    private createUninitializedStoredSession;
+    private loadSessionRuntime;
+    private repairLoadedSession;
+    private repairTerminal;
+    private mutateScope;
+    private mutateProjection;
+    private mutatePermissions;
+    private createScopeSnapshot;
+    private createProjectionSnapshot;
+    private cleanupSessionDomains;
+    private finishTombstoneCleanup;
+    private finishTombstoneCleanupInternal;
+    private fenceNamespace;
+    private closeStoredSession;
+    private abortStoredSession;
+    private storedSessionCleanupCompleted;
+    private releasePartialProviderSession;
+    private retainPartialProviderSession;
+    private hasOrphanedSessionResources;
+    private closeOrphanedResources;
+    private closeOrphanedResourcesInternal;
+    private orphanedResourceStorageKeys;
+    private retireScopeInternal;
+    private drainStorage;
+    private drainStorageInternal;
+    private disposeInternal;
+    private appendUnexpectedErrors;
+    private resolveState;
+    private getScopeAdmission;
+    private pruneScopeAdmission;
+    private createScopeRetirementError;
+    private assertStateAcceptingWork;
+    private requireSession;
+    private requireMutableSession;
+    private requireMessage;
+    private isTombstoned;
+    private emitPartEvent;
+    private emitEvent;
+    private validateRuntimeEvent;
+    private projectBackgroundExecution;
+    private boundedIdentifier;
     private messageCursorNamespace;
     private createMessageCursor;
     private parseMessageCursor;
-    private resolveRunAdmission;
-    private rejectRunAdmission;
-    private requireSession;
-    private requireMessage;
-    private requireMutableSession;
     private assertOpen;
 }