@qvac/harness 0.7.1 → 1.0.0-rc.1

package/dist-lib/lib/connect.d.ts

@@ -9,7 +9,12 @@ import type { DeleteModelSummary } from './models/model-delete.ts';
 import type { CopyBaseResult, DeleteOverlayResult, ManagedSkill, SkillFileContent } from './tools/skills/overlay-crud.ts';
 import type { SkillSettingEntry } from './tools/skills/skill-settings.ts';
 export declare const HARNESS_DIED = "HARNESS_DIED";
-export declare function connectHarness(transport: Transport): RemoteHarness;
+export interface ConnectOptions {
+    pauseGraceMs?: number;
+    runLogReleaseTimeoutMs?: number;
+}
+export type { HostRunLog, HostRunLogLease, RunRecord } from './contract-types.ts';
+export declare function connectHarness(transport: Transport, options?: ConnectOptions): RemoteHarness;
 export declare function readEmbeddingDeviceResponse(response: unknown): EmbedDevice;
 export declare class RemoteHarness extends EventEmitter implements HarnessContract {
     on: (event: 'model' | 'status', listener: (...args: never[]) => void) => this;
@@ -18,11 +23,13 @@ export declare class RemoteHarness extends EventEmitter implements HarnessContra
     private _session;
     private _opening;
     private _closed;
+    private readonly _pauseGraceMs;
+    private readonly _runLogReleaseTimeoutMs;
     private _customModels;
-    constructor(transport: Transport);
+    constructor(transport: Transport, options?: ConnectOptions);
     private _ensure;
     private _open;
-    completion(context: CompletionContext): AsyncIterable<HarnessEvent>;
+    completion(context: CompletionContext | import('./contract-types.ts').ResumeCompletionContext): AsyncIterable<HarnessEvent>;
     invoke(context: InvokeContext): AsyncIterable<HarnessEvent>;
     private _run;
     download(context: DownloadContext): AsyncIterable<HarnessEvent>;

package/dist-lib/lib/connect.js

@@ -1,3 +1,5 @@
+import b4a from 'b4a';
+import { randomBytes } from 'crypto';
 import EventEmitter from 'events';
 import fs from 'fs';
 import { z } from 'zod';
@@ -6,6 +8,7 @@ import { harnessClient } from '../spec/calls.js';
 import HRPC from '../spec/hrpc/index.js';
 import { unsupportedKvCacheDeletion } from './capabilities/kv-cache.js';
 import { readModelSourcePreview } from './capabilities/preview-model-source.js';
+import { validateEngineBoot } from './run-log-protocol.js';
 import { hlog } from './log.js';
 import { assertEmbedDevice } from './models/embed-config.js';
 import { addonTaskType } from './models/model-task.js';
@@ -17,8 +20,9 @@ import { SKILL_STATE } from './tools/skills/skill-state.js';
 import { asToolset } from './tools/toolsets.js';
 import { fromDownloadWire, fromWire, unpackVectors } from './wire.js';
 export const HARNESS_DIED = 'HARNESS_DIED';
-export function connectHarness(transport) {
-    return new RemoteHarness(transport);
+const PAUSE_GRACE_MS = 10_000;
+export function connectHarness(transport, options = {}) {
+    return new RemoteHarness(transport, options);
 }
 export function readEmbeddingDeviceResponse(response) {
     const device = isRecord(response) ? response.device : undefined;
@@ -33,10 +37,14 @@ export class RemoteHarness extends EventEmitter {
     _session = null;
     _opening = null;
     _closed = false;
+    _pauseGraceMs;
+    _runLogReleaseTimeoutMs;
     _customModels = [];
-    constructor(transport) {
+    constructor(transport, options = {}) {
         super();
         this._transport = transport;
+        this._pauseGraceMs = options.pauseGraceMs ?? PAUSE_GRACE_MS;
+        this._runLogReleaseTimeoutMs = options.runLogReleaseTimeoutMs ?? 5000;
     }
     _ensure() {
         if (this._closed) {
@@ -97,16 +105,32 @@ export class RemoteHarness extends EventEmitter {
         return session;
     }
     async *completion(context) {
+        const runId = context.runId ?? b4a.toHex(randomBytes(16));
+        if (context.signal?.aborted) {
+            yield { type: 'aborted', runId };
+            return;
+        }
+        const explicitEmptyIdentity = explicitEmptyIdentityFields(context);
+        const payload = {
+            resume: context.resume === true,
+            recoveryEvents: true,
+            resolutions: context.recovery
+        };
+        if (explicitEmptyIdentity.length) {
+            payload.explicitEmptyIdentity = explicitEmptyIdentity;
+        }
         yield* this._run({
             type: 'start',
+            runId,
+            payload,
             model: context.model,
-            agent: knobs(context.agent),
+            agent: context.agent ? knobs(context.agent) : undefined,
             cacheKey: context.cacheKey,
             thinkingDefault: context.thinkingDefault,
             generationParams: context.generationParams,
             responseFormat: context.responseFormat,
             captureInferenceCalls: context.captureInferenceCalls,
-            messages: context.messages.map(({ role, content, attachments }) => ({
+            messages: context.messages?.map(({ role, content, attachments }) => ({
                 role,
                 content,
                 attachments: attachments?.map(({ path: file }) => ({ path: file }))
@@ -115,7 +139,7 @@ export class RemoteHarness extends EventEmitter {
             grantedDirs: context.grantedDirs,
             grantedDrives: context.grantedDrives,
             grantedWriteDirs: context.grantedWriteDirs
-        }, context);
+        }, { ...context, runId });
     }
     async *invoke(context) {
         const agent = context.agent ?? {};
@@ -136,8 +160,62 @@ export class RemoteHarness extends EventEmitter {
         });
     }
     async *_run(open, context) {
-        const { client } = await this._ensure();
+        if (context.signal?.aborted) {
+            yield { type: 'aborted', runId: context.runId ?? open.runId ?? undefined };
+            return;
+        }
+        let session;
+        try {
+            session = await awaitWithAbort(this._ensure(), context.signal);
+        }
+        catch (err) {
+            if (context.signal?.aborted) {
+                yield { type: 'aborted', runId: context.runId ?? open.runId ?? undefined };
+                return;
+            }
+            throw err;
+        }
+        const { client } = session;
+        let pausable = false;
+        const peer = this.capability().then((c) => {
+            pausable = c.hostRunLog === true && c.hostRunLogVersion === 1;
+            return c;
+        }, () => null);
+        const canResume = async () => {
+            const c = await peer;
+            return context.runLog
+                ? c?.hostRunLog === true && c.hostRunLogVersion === 1
+                : c?.completionRecovery === true;
+        };
+        let capability;
+        try {
+            capability = await awaitWithAbort(peer, context.signal);
+        }
+        catch (err) {
+            if (context.signal?.aborted) {
+                yield { type: 'aborted', runId: context.runId ?? open.runId ?? undefined };
+                return;
+            }
+            throw err;
+        }
+        if (context.runLog && (capability?.hostRunLog !== true || capability.hostRunLogVersion !== 1)) {
+            throw new Error('This peer does not support a host-owned run log');
+        }
+        if (context.resume && !(await canResume())) {
+            throw new Error('This peer does not support persistent completion recovery');
+        }
+        let activeRunId = context.runId ?? open.runId ?? undefined;
+        if (context.signal?.aborted) {
+            yield { type: 'aborted', runId: activeRunId };
+            return;
+        }
+        const leasedRunId = context.runLog ? activeRunId : undefined;
+        if (context.runLog && !leasedRunId) {
+            throw new Error('host-owned run log requires a run id');
+        }
+        let hostLease;
         let duplex = null;
+        let startFrame = open;
         let emittedAborted = false;
         const staged = [];
         let closed = false;
@@ -147,36 +225,67 @@ export class RemoteHarness extends EventEmitter {
                 void fs.promises.unlink(file).catch(noop);
             }
         };
-        const onAbort = () => duplex?.destroy();
+        let pauseTimer;
+        let started = false;
+        const onAbort = () => {
+            if (!pausable || !duplex || !started) {
+                return duplex?.destroy();
+            }
+            duplex.write({ type: 'pause' });
+            pauseTimer = setTimeout(() => duplex?.destroy(), this._pauseGraceMs);
+        };
         try {
+            if (context.runLog) {
+                const leaseResult = await acquireHostRunLogLease(context.runLog, leasedRunId, context.signal);
+                if (leaseResult === null) {
+                    yield { type: 'aborted', runId: activeRunId };
+                    return;
+                }
+                hostLease = leaseResult;
+            }
+            if (hostLease) {
+                validateHostRunLogLease(hostLease, leasedRunId);
+                const payload = isRecord(open.payload) ? { ...open.payload } : {};
+                payload.resume =
+                    context.resume === true ||
+                        (hostLease.boot !== undefined && hostLease.boot.metadata !== null);
+                payload.runLog = {
+                    boot: hostLease.boot ?? null,
+                    digestKey: b4a.toHex(hostLease.digestKey),
+                    hostAppendTimeoutMs: context.hostAppendTimeoutMs
+                };
+                startFrame = { ...open, payload };
+            }
+            if (context.signal?.aborted) {
+                yield { type: 'aborted', runId: activeRunId };
+                return;
+            }
+            context.signal?.addEventListener?.('abort', onAbort, { once: true });
             duplex = client.completion();
-            duplex.write(open);
             if (context.signal?.aborted) {
                 duplex.destroy();
-                yield { type: 'aborted' };
+                yield { type: 'aborted', runId: activeRunId };
                 return;
             }
-            context.signal?.addEventListener?.('abort', onAbort, { once: true });
+            duplex.write(startFrame);
+            started = true;
             hlog('client wire open', { model: context.model, capability: open.capability });
             for await (const event of frames(duplex)) {
                 received++;
                 if (event.type !== 'content' && event.type !== 'thinking') {
                     hlog('client frame', { type: event.type, n: received });
                 }
+                if (event.type === 'run-started' || event.type === 'run-resumed') {
+                    activeRunId = event.runId ?? activeRunId;
+                }
                 if (event.type === 'done') {
                     break;
                 }
                 if (event.type === 'approval-ask') {
                     const callId = event.callId;
+                    const approval = approvalCall(event);
                     void Promise.resolve()
-                        .then(() => context.approve?.({
-                        name: event.name ?? '',
-                        arguments: isRecord(event.arguments) ? event.arguments : {},
-                        resource: event.resource ?? null,
-                        effect: event.effect === 'read' ? 'read' : 'write',
-                        intent: event.intent || null,
-                        display: isToolCallDisplay(event.display) ? event.display : null
-                    }))
+                        .then(() => context.approve?.(approval))
                         .then((approved) => {
                         if (!closed) {
                             duplex.write({ type: 'decision', callId, approved: approved === true });
@@ -248,6 +357,30 @@ export class RemoteHarness extends EventEmitter {
                         .catch((err) => hlog('drive reply failed', { callId, message: errorMessage(err) }));
                     continue;
                 }
+                if (event.type === 'run-log-append') {
+                    const callId = event.callId;
+                    void bridgeRunLog({
+                        event,
+                        context,
+                        runId: leasedRunId,
+                        generation: hostLease?.generation
+                    })
+                        .then((frame) => {
+                        if (!closed) {
+                            duplex.write({ ...frame, callId });
+                        }
+                    }, (err) => {
+                        if (!closed) {
+                            duplex.write({
+                                type: 'run-log-result',
+                                callId,
+                                message: errorMessage(err)
+                            });
+                        }
+                    })
+                        .catch((err) => hlog('run-log reply failed', { callId, message: errorMessage(err) }));
+                    continue;
+                }
                 if (event.type === 'rag-ask') {
                     const callId = event.callId;
                     void bridgeRag(event, context)
@@ -283,7 +416,7 @@ export class RemoteHarness extends EventEmitter {
                     continue;
                 }
                 const wire = fromWire(event);
-                if (wire.type === 'aborted') {
+                if (wire.type === 'aborted' || wire.type === 'paused') {
                     emittedAborted = true;
                 }
                 yield wire;
@@ -293,21 +426,42 @@ export class RemoteHarness extends EventEmitter {
         catch (err) {
             if (context.signal?.aborted) {
                 if (!emittedAborted) {
-                    yield { type: 'aborted' };
+                    yield { type: 'aborted', runId: activeRunId };
                 }
                 return;
             }
+            if (!started) {
+                throw err;
+            }
             throw died(`harness died mid-run: ${errorMessage(err)}`);
         }
         finally {
             hlog('client run end', { received, aborted: Boolean(context.signal?.aborted) });
             context.signal?.removeEventListener?.('abort', onAbort);
+            clearTimeout(pauseTimer);
             duplex?.destroy();
             closed = true;
             reclaim();
+            if (hostLease && leasedRunId && context.runLog) {
+                let timer;
+                try {
+                    await Promise.race([
+                        context.runLog.release(leasedRunId, hostLease.generation),
+                        new Promise((_resolve, reject) => {
+                            timer = setTimeout(() => reject(new Error('host run-log release timed out')), this._runLogReleaseTimeoutMs);
+                        })
+                    ]);
+                }
+                catch (err) {
+                    hlog('host run-log release failed', { runId: leasedRunId, message: errorMessage(err) });
+                }
+                finally {
+                    clearTimeout(timer);
+                }
+            }
         }
         if (context.signal?.aborted && !emittedAborted) {
-            yield { type: 'aborted' };
+            yield { type: 'aborted', runId: activeRunId };
         }
     }
     async *download(context) {
@@ -616,7 +770,7 @@ export class RemoteHarness extends EventEmitter {
         const { client } = await this._ensure();
         const response = await client.capability({});
         const memoryBudget = response.memoryBudget;
-        return {
+        const capability = {
             capabilityProfile: response.capabilityProfile,
             recommendedModelName: response.recommendedModelName,
             memoryBudget: memoryBudget
@@ -629,6 +783,16 @@ export class RemoteHarness extends EventEmitter {
                 : undefined,
             mobile: response.mobile === true
         };
+        if (response.completionRecovery === true) {
+            capability.completionRecovery = true;
+        }
+        if (response.hostRunLog === true) {
+            capability.hostRunLog = true;
+        }
+        if (response.hostRunLogVersion && response.hostRunLogVersion > 0) {
+            capability.hostRunLogVersion = response.hostRunLogVersion;
+        }
+        return capability;
     }
     close() {
         this._closed = true;
@@ -719,6 +883,28 @@ function knobs(agent) {
         sandboxMode: agent.sandboxMode ?? undefined
     };
 }
+function explicitEmptyIdentityFields(context) {
+    const fields = [];
+    if (context.model === '') {
+        fields.push('model');
+    }
+    if (context.cacheKey === '') {
+        fields.push('cacheKey');
+    }
+    if (context.thinkingDefault === '') {
+        fields.push('thinkingDefault');
+    }
+    if (context.agent?.id === '') {
+        fields.push('agent.id');
+    }
+    if (context.agent?.name === '') {
+        fields.push('agent.name');
+    }
+    if (context.agent?.bio === '') {
+        fields.push('agent.bio');
+    }
+    return fields;
+}
 async function bridgeAttach(event, attach) {
     try {
         if (!attach) {
@@ -839,6 +1025,126 @@ function answerQuestion(event, { askUser, reply }) {
         .then((answer) => reply({ type: 'question-result', callId, answer: answer ?? '' }), (err) => reply({ type: 'question-result', callId, message: errorMessage(err) }))
         .catch((err) => hlog('question reply failed', { callId, message: errorMessage(err) }));
 }
+async function bridgeRunLog({ event, context, runId, generation }) {
+    if (!context.runLog || !generation) {
+        return { type: 'run-log-result', message: 'the host does not own this run log' };
+    }
+    const step = event.payload;
+    if (!isEngineStep(step)) {
+        return { type: 'run-log-result', message: 'the worker sent an invalid run-log step' };
+    }
+    try {
+        await context.runLog.append(runId ?? '', generation, step);
+        return { type: 'run-log-result' };
+    }
+    catch (err) {
+        return { type: 'run-log-result', message: errorMessage(err) };
+    }
+}
+function isEngineStep(value) {
+    return (isRecord(value) &&
+        typeof value.seq === 'number' &&
+        Number.isSafeInteger(value.seq) &&
+        value.seq >= 0 &&
+        typeof value.expectedLength === 'number' &&
+        Number.isSafeInteger(value.expectedLength) &&
+        value.expectedLength >= 0 &&
+        Array.isArray(value.records));
+}
+function isDigestKey(value) {
+    return value instanceof Uint8Array && value.byteLength === 32;
+}
+function releaseLateHostLease(pending, runLog, runId) {
+    void pending
+        .then(async (lease) => {
+        if (!lease || typeof lease.generation !== 'string' || !lease.generation) {
+            throw new Error('host returned an invalid generation for an aborted run-log begin');
+        }
+        await runLog.release(runId, lease.generation);
+    })
+        .catch((err) => hlog('aborted run-log begin cleanup failed', {
+        runId,
+        message: errorMessage(err)
+    }));
+}
+function validateHostRunLogLease(lease, runId) {
+    if (typeof lease.generation !== 'string' || !lease.generation || !isDigestKey(lease.digestKey)) {
+        throw new Error('host returned an invalid run-log lease');
+    }
+    if (lease.boot) {
+        validateEngineBoot(lease.boot);
+    }
+    const metadata = lease.boot?.metadata;
+    if (metadata && metadata.runId !== runId) {
+        throw new Error('host returned a run-log boot for a different run');
+    }
+}
+function approvalCall(event) {
+    const identity = isRecord(event.payload) ? event.payload : {};
+    const approval = {
+        name: event.name ?? '',
+        arguments: isRecord(event.arguments) ? event.arguments : {},
+        resource: event.resource ?? null,
+        effect: event.effect === 'read' ? 'read' : 'write',
+        intent: event.intent || null,
+        display: isToolCallDisplay(event.display) ? event.display : null
+    };
+    if (typeof identity.callId === 'string') {
+        approval.callId = identity.callId;
+    }
+    if (typeof identity.round === 'number') {
+        approval.round = identity.round;
+    }
+    return approval;
+}
+async function acquireHostRunLogLease(runLog, runId, signal) {
+    if (!runId) {
+        throw new Error('host-owned run log requires a run id');
+    }
+    const pending = runLog.begin(runId);
+    try {
+        return await awaitWithAbort(pending, signal);
+    }
+    catch (err) {
+        if (!signal?.aborted) {
+            throw err;
+        }
+        releaseLateHostLease(pending, runLog, runId);
+        return null;
+    }
+}
+function awaitWithAbort(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted) {
+        return Promise.reject(new Error('operation aborted'));
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => signal.removeEventListener?.('abort', onAbort);
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(new Error('operation aborted'));
+        };
+        signal.addEventListener?.('abort', onAbort, { once: true });
+        promise.then((value) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error);
+        });
+    });
+}
 async function bridgeRag(event, context) {
     if (!context.ragSearch) {
         return {

package/dist-lib/lib/contract-types.d.ts

@@ -13,7 +13,9 @@ import type { ManagedSkill, SkillFileContent } from './tools/skills/overlay-crud
 import type { DriveOpFn, GrantedDrive } from './tools/fs/remote.ts';
 import type { ResolvedSkillCatalogEntry } from './tools/skills/catalog.ts';
 import type { InstallStep, SkillSetup } from './tools/skills/manifest.ts';
-export type { InstallStep, ListModelsOptions, ModelInfo, ResolvedSkillCatalogEntry, ResourceDescriptor, SkillSetup, ToolCatalogEntry };
+import type { EngineBoot, EngineStep, HostRunLog, HostRunLogLease, RecoveryResolution, RunRecord } from './run-log-protocol.ts';
+export type { InstallStep, ListModelsOptions, ModelInfo, ResolvedSkillCatalogEntry, ResourceDescriptor, RunRecord, SkillSetup, ToolCatalogEntry };
+export type { HostRunLog, HostRunLogLease };
 export type ApprovalCall = Parameters<ApproveFn>[0];
 export interface ChatMessage {
     role: 'system' | 'user' | 'assistant' | 'tool';
@@ -43,6 +45,9 @@ export interface AgentKnobs {
     sandboxMode?: boolean | null;
 }
 export interface CompletionContext {
+    runId?: string;
+    resume?: boolean;
+    recovery?: RecoveryResolution[];
     model: string;
     agent: AgentKnobs;
     messages: ChatMessage[];
@@ -62,6 +67,11 @@ export interface CompletionContext {
     ragSearch?: RagSearchFn;
     progress?: ProgressFn;
     askUser?: AskUserFn;
+    runLog?: HostRunLog;
+    boot?: EngineBoot;
+    onStep?: (step: EngineStep) => Promise<void>;
+    hostAppendTimeoutMs?: number;
+    requestDigestKey?: Uint8Array;
     signal?: {
         aborted?: boolean;
         addEventListener?: (type: 'abort', fn: () => void, opts?: {
@@ -70,6 +80,10 @@ export interface CompletionContext {
         removeEventListener?: (type: 'abort', fn: () => void) => void;
     };
 }
+export type ResumeCompletionContext = Omit<Partial<CompletionContext>, 'runId' | 'resume'> & {
+    runId: string;
+    resume: true;
+};
 export interface InvokeContext {
     capability: string;
     args: Record<string, unknown>;
@@ -172,6 +186,9 @@ export interface HarnessInfo {
     supportsKvCacheDeletion?: boolean;
 }
 export interface CapabilityInfo {
+    completionRecovery?: boolean;
+    hostRunLog?: boolean;
+    hostRunLogVersion?: number;
     capabilityProfile: HarnessCapabilityProfile;
     recommendedModelName: string;
     memoryBudget?: MemoryBudget;
@@ -196,7 +213,7 @@ export interface InfraModel {
     addon: string;
 }
 export interface HarnessContract {
-    completion(context: CompletionContext): AsyncIterable<HarnessEvent>;
+    completion(context: CompletionContext | ResumeCompletionContext): AsyncIterable<HarnessEvent>;
     invoke?(context: InvokeContext): AsyncIterable<HarnessEvent>;
     download?(context: DownloadContext): AsyncIterable<HarnessEvent>;
     describe?(): Promise<HarnessInfo | null> | HarnessInfo;

package/dist-lib/lib/harness-lifecycle.d.ts

@@ -0,0 +1,66 @@
+import { type SnapshotFrom } from 'xstate';
+type Request = 'SUSPEND' | 'RESUME' | 'WAKEUP';
+export interface LifecycleEvent {
+    type: 'PRESUSPEND' | 'CLOSE' | Request;
+}
+export interface LifecycleWork {
+    suspend(): Promise<void>;
+    resume(): Promise<void>;
+}
+interface LifecycleContext {
+    pending: Request | null;
+    failureCount: number;
+    failureMessage: string | null;
+}
+export declare const harnessLifecycle: import("xstate").StateMachine<LifecycleContext, LifecycleEvent, {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
+}, {
+    src: "resume";
+    logic: import("xstate").PromiseActorLogic<void, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "suspend";
+    logic: import("xstate").PromiseActorLogic<void, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
+    id: string | undefined;
+}, {
+    type: "clear";
+    params: import("xstate").NonReducibleUnknown;
+} | {
+    type: "hold";
+    params: import("xstate").NonReducibleUnknown;
+} | {
+    type: "recordError";
+    params: import("xstate").NonReducibleUnknown;
+} | {
+    type: "report";
+    params: unknown;
+}, {
+    type: "resumeHeld";
+    params: unknown;
+} | {
+    type: "suspendHeld";
+    params: unknown;
+} | {
+    type: "wakeupHeld";
+    params: unknown;
+}, never, "presuspended" | "resuming" | "running" | "suspended" | "suspending" | "waking", string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
+    id: "harness";
+    states: {
+        readonly running: {};
+        readonly presuspended: {};
+        readonly suspending: {};
+        readonly suspended: {};
+        readonly resuming: {};
+        readonly waking: {};
+    };
+}, import("xstate").MetaObject>;
+export interface HarnessLifecycle {
+    readonly suspended: boolean;
+    readonly state: SnapshotFrom<typeof harnessLifecycle>['value'];
+    send(type: LifecycleEvent['type']): Promise<void>;
+    settled(): Promise<SnapshotFrom<typeof harnessLifecycle>>;
+    cancelPending(): void;
+    stop(): void;
+}
+export declare function createHarnessLifecycle(work: LifecycleWork): HarnessLifecycle;
+export {};