@hunterzhu/pulse-runtime 0.1.5 → 0.1.7

package/dist/context/builder.d.ts

@@ -1,16 +1,21 @@
-import type { AgentRecord, ArtifactRef, LaneRecord, LLMRequestProjection, PrivacyLabel, PrivacyTaint, ResultRef, RuntimeState, JsonValue, ContextDelta } from '../core/types.js';
+import type { AgentRecord, ArtifactRef, ConversationMessage, LaneRecord, LLMRequestProjection, PrivacyLabel, PrivacyTaint, ResultRef, RuntimeState, JsonValue, ContextDelta } from '../core/types.js';
 export interface ContextBuildInput {
     agent: AgentRecord;
     lane: LaneRecord;
     resultRefs?: ResultRef[];
     artifactRefs?: ArtifactRef[];
     eventIds?: string[];
+    conversation?: ConversationMessage[];
     instruction: string;
     system?: string;
     policy?: JsonValue;
     tools?: JsonValue;
     toolSetId: string;
 }
+export declare const MAX_DSL_INSTRUCTION_BYTES = 2048;
+/** Keep large tool results from crowding out the actual task and conversation. */
+export declare const MAX_INLINE_RESULT_BYTES = 4096;
+export declare function assertDslInstructionSize(value: string): string;
 export declare class ContextBuilder {
     private readonly state;
     readonly version = "1";

package/dist/context/builder.js

@@ -8,6 +8,35 @@ function stable(value) {
     return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${stable(item)}`).join(',')}}`;
 }
 function hash(value) { return createHash('sha256').update(stable(value)).digest('hex'); }
+export const MAX_DSL_INSTRUCTION_BYTES = 2_048;
+/** Keep large tool results from crowding out the actual task and conversation. */
+export const MAX_INLINE_RESULT_BYTES = 4_096;
+function utf8Prefix(value, maxBytes) {
+    return Buffer.from(value, 'utf8').subarray(0, maxBytes).toString('utf8');
+}
+function projectResultValue(result) {
+    const value = result.value ?? null;
+    const originalBytes = Buffer.byteLength(JSON.stringify(value), 'utf8');
+    if (originalBytes <= MAX_INLINE_RESULT_BYTES)
+        return { value, summarized: false };
+    if (result.summary !== undefined)
+        return { value: result.summary, summarized: true, originalBytes };
+    return {
+        value: {
+            truncated: true,
+            originalBytes,
+            preview: utf8Prefix(JSON.stringify(value), MAX_INLINE_RESULT_BYTES),
+            note: 'The full result is retained by the runtime. Use this preview. Do not re-run the producing tool.',
+        },
+        summarized: true,
+        originalBytes,
+    };
+}
+export function assertDslInstructionSize(value) {
+    if (Buffer.byteLength(value, 'utf8') > MAX_DSL_INSTRUCTION_BYTES)
+        throw Object.assign(new Error('Instruction exceeds the 2 KB DSL limit.'), { code: 'INSTRUCTION_TOO_LARGE', retryable: false });
+    return value;
+}
 export class ContextBuilder {
     state;
     version = '1';
@@ -15,8 +44,7 @@ export class ContextBuilder {
         this.state = state;
     }
     build(input) {
-        if (input.instruction.length > 2048)
-            throw new Error('INSTRUCTION_TOO_LARGE');
+        assertDslInstructionSize(input.instruction);
         const global = input.agent.globalVersions.get(input.lane.contextSnapshotVersion);
         if (global === undefined)
             throw new Error('UNKNOWN_CONTEXT_VERSION');
@@ -55,15 +83,20 @@ export class ContextBuilder {
             ...effectiveResults.flatMap((item) => (item.result.privacyTaints ?? []).map((taint) => ({ path: [item.result.id, ...taint.path], privacy: taint.privacy }))),
             ...effectiveArtifacts.flatMap((item) => (item.artifact.privacyTaints ?? []).map((taint) => ({ path: [item.artifact.ref, ...taint.path], privacy: taint.privacy }))),
         ];
-        const contextSpec = { globalSnapshotVersion: input.lane.contextSnapshotVersion, laneSnapshotVersion: input.lane.context.version, resultRefs, ...(artifactRefs.length ? { artifactRefs } : {}), eventIds: input.eventIds ?? [], toolSetId: input.toolSetId, instruction: input.instruction, privacy, privacyRefs, ...(privacyTaints.length ? { privacyTaints } : {}) };
+        const conversation = input.conversation ?? [];
+        const contextSpec = { globalSnapshotVersion: input.lane.contextSnapshotVersion, laneSnapshotVersion: input.lane.context.version, resultRefs, ...(artifactRefs.length ? { artifactRefs } : {}), eventIds: input.eventIds ?? [], toolSetId: input.toolSetId, instruction: input.instruction, ...(conversation.length ? { conversation: structuredClone(conversation) } : {}), privacy, privacyRefs, ...(privacyTaints.length ? { privacyTaints } : {}) };
         const prefixBlocks = [
             { kind: 'system', content: input.system ?? '' },
             { kind: 'policy', content: input.policy ?? {} },
             { kind: 'tools', content: input.tools ?? {} },
             { kind: 'global', content: global },
+            ...(conversation.length ? [{ kind: 'conversation', content: structuredClone(conversation) }] : []),
             { kind: 'history', content: input.lane.context.history.map((record) => ({ seq: record.seq, ...(record.effectId === undefined ? {} : { effectId: record.effectId }), instruction: record.instruction, resultRefs: record.resultRefs, ...(record.resultSelection === undefined ? {} : { resultSelection: record.resultSelection }), ...(record.result === undefined ? {} : { result: record.result }), ...(record.findings === undefined ? {} : { findings: record.findings }), output: record.output, privacy: record.privacy, ...(record.privacyTaints === undefined ? {} : { privacyTaints: record.privacyTaints }) })) },
         ];
-        const blocks = [...prefixBlocks, { kind: 'lane', content: input.lane.context.state }, { kind: 'events', content: input.eventIds ?? [] }, { kind: 'results', content: results.map((result) => ({ id: result.id, value: result.value ?? null, ...(result.privacyTaints === undefined ? {} : { privacyTaints: result.privacyTaints.map((taint) => ({ path: [...taint.path], privacy: taint.privacy })) }) })) }, { kind: 'artifacts', content: artifacts.map((artifact) => ({ ref: artifact.ref, mediaType: artifact.mediaType, sizeBytes: artifact.sizeBytes, contentHash: artifact.contentHash })) }, { kind: 'instruction', content: input.instruction }];
+        const blocks = [...prefixBlocks, { kind: 'lane', content: input.lane.context.state }, { kind: 'events', content: input.eventIds ?? [] }, { kind: 'results', content: results.map((result) => {
+                    const projected = projectResultValue(result);
+                    return { id: result.id, value: projected.value, ...(projected.summarized ? { summarized: true, ...(projected.originalBytes === undefined ? {} : { originalBytes: projected.originalBytes }) } : {}), ...(result.privacyTaints === undefined ? {} : { privacyTaints: result.privacyTaints.map((taint) => ({ path: [...taint.path], privacy: taint.privacy })) }) };
+                }) }, { kind: 'artifacts', content: artifacts.map((artifact) => ({ ref: artifact.ref, mediaType: artifact.mediaType, sizeBytes: artifact.sizeBytes, contentHash: artifact.contentHash })) }, { kind: 'instruction', content: input.instruction }];
         return { contextSpec, blocks, prefixHash: hash(prefixBlocks), projectionHash: hash(blocks), builderVersion: this.version, policyVersion: '1', toolSetVersion: input.toolSetId, privacy, privacyRefs, ...(privacyTaints.length ? { privacyTaints } : {}) };
     }
 }

package/dist/core/inbox.d.ts

@@ -57,6 +57,8 @@ export interface FactInboxSnapshot<T extends JsonValue = JsonValue> {
     nextSeq: number;
     seen: string[];
     queue: FactEnvelope<T>[];
+    /** Number of queued urgent entries at the head of `queue` (v2+). */
+    urgentCount?: number;
     dedupeLedger?: FactInboxDedupeLedgerSnapshot;
 }
 export declare class FactInbox<T extends JsonValue = JsonValue> {
@@ -64,13 +66,17 @@ export declare class FactInbox<T extends JsonValue = JsonValue> {
     private readonly seen;
     private nextSeq;
     private archivedThrough;
+    private urgentCount;
     private dedupeArchive;
     constructor(options?: {
         dedupeArchive?: FactInboxDedupeArchive;
     });
     /** Attach a backend-provided archive before the first compaction. */
     attachDedupeArchive(archive: FactInboxDedupeArchive): void;
+    private enqueueInternal;
     enqueue(fact: T, eventId: string): FactEnvelope<T> | undefined;
+    /** Insert a host control fact ahead of already queued background work. */
+    enqueueUrgent(fact: T, eventId: string): FactEnvelope<T> | undefined;
     drain(limit?: number): FactEnvelope<T>[];
     get size(): number;
     get dedupeWatermark(): number;

package/dist/core/inbox.js

@@ -14,6 +14,7 @@ export class FactInbox {
     seen = new Map();
     nextSeq = 1;
     archivedThrough = 0;
+    urgentCount = 0;
     dedupeArchive;
     constructor(options = {}) {
         this.dedupeArchive = options.dedupeArchive;
@@ -26,18 +27,28 @@ export class FactInbox {
             throw new Error('FACT_INBOX_DEDUPE_ARCHIVE_ALREADY_COMPACTED');
         this.dedupeArchive = archive;
     }
-    enqueue(fact, eventId) {
+    enqueueInternal(fact, eventId, urgent) {
         if (!eventId || this.seen.has(eventId) || this.dedupeArchive?.contains(eventId))
             return undefined;
         const envelope = { eventId, receivedSeq: this.nextSeq++, fact: structuredClone(fact) };
         this.seen.set(eventId, envelope.receivedSeq);
-        this.queue.push(envelope);
+        if (urgent) {
+            this.queue.splice(this.urgentCount, 0, envelope);
+            this.urgentCount++;
+        }
+        else
+            this.queue.push(envelope);
         return structuredClone(envelope);
     }
+    enqueue(fact, eventId) { return this.enqueueInternal(fact, eventId, false); }
+    /** Insert a host control fact ahead of already queued background work. */
+    enqueueUrgent(fact, eventId) { return this.enqueueInternal(fact, eventId, true); }
     drain(limit = Number.POSITIVE_INFINITY) {
         if (limit !== Number.POSITIVE_INFINITY && (!Number.isInteger(limit) || limit < 0))
             throw new Error('INVALID_FACT_DRAIN_LIMIT');
-        return this.queue.splice(0, limit).map((envelope) => structuredClone(envelope));
+        const drained = this.queue.splice(0, limit);
+        this.urgentCount = Math.max(0, this.urgentCount - drained.length);
+        return drained.map((envelope) => structuredClone(envelope));
     }
     get size() { return this.queue.length; }
     get dedupeWatermark() { return this.archivedThrough; }
@@ -50,6 +61,7 @@ export class FactInbox {
             nextSeq: this.nextSeq,
             seen: [...this.seen.keys()],
             queue: this.queue.map((envelope) => structuredClone(envelope)),
+            ...(this.urgentCount === 0 ? {} : { urgentCount: this.urgentCount }),
             dedupeLedger: {
                 schemaVersion: 1,
                 archivedThrough: this.archivedThrough,
@@ -117,10 +129,11 @@ export class FactInbox {
             this.seen.set(eventId, receivedSeq);
         this.nextSeq = restored.nextSeq;
         this.archivedThrough = restored.archivedThrough;
+        this.urgentCount = restored.urgentCount;
     }
     static fromSnapshot(snapshot, options = {}) {
         const value = snapshot;
-        if (!value || (value.schemaVersion !== 1 && value.schemaVersion !== 2) || !Number.isInteger(value.nextSeq) || value.nextSeq < 1 || !Array.isArray(value.seen) || value.seen.some((eventId) => typeof eventId !== 'string' || eventId.length === 0) || !Array.isArray(value.queue))
+        if (!value || (value.schemaVersion !== 1 && value.schemaVersion !== 2) || !Number.isInteger(value.nextSeq) || value.nextSeq < 1 || !Array.isArray(value.seen) || value.seen.some((eventId) => typeof eventId !== 'string' || eventId.length === 0) || !Array.isArray(value.queue) || (value.urgentCount !== undefined && (!Number.isInteger(value.urgentCount) || value.urgentCount < 0 || value.urgentCount > value.queue.length)))
             throw new Error('INVALID_FACT_INBOX_SNAPSHOT');
         if (new Set(value.seen).size !== value.seen.length)
             throw new Error('INVALID_FACT_INBOX_SNAPSHOT');
@@ -151,8 +164,8 @@ export class FactInbox {
                 throw new Error('INVALID_FACT_INBOX_SNAPSHOT');
             if (inbox.queue.some((candidate) => candidate.eventId === envelope.eventId || candidate.receivedSeq === envelope.receivedSeq))
                 throw new Error('INVALID_FACT_INBOX_SNAPSHOT');
-            if (envelope.receivedSeq <= maxReceivedSeq)
-                throw new Error('INVALID_FACT_INBOX_SNAPSHOT');
+            // Urgent host facts may be inserted ahead of older entries, so queue
+            // order is intentionally different from received sequence order.
             const knownSeq = seen.get(envelope.eventId);
             if (knownSeq !== undefined && knownSeq !== envelope.receivedSeq)
                 throw new Error('INVALID_FACT_INBOX_SNAPSHOT');
@@ -161,14 +174,25 @@ export class FactInbox {
             inbox.queue.push({ eventId: envelope.eventId, receivedSeq: envelope.receivedSeq, fact: structuredClone(envelope.fact) });
             maxReceivedSeq = Math.max(maxReceivedSeq, envelope.receivedSeq);
         }
+        // Preserve the serialized queue order. Urgent entries are allowed to have
+        // newer receivedSeq values ahead of background entries, but each priority
+        // band must retain its own FIFO order. This rejects ambiguous snapshots
+        // instead of silently normalizing a caller-provided reorder.
+        const urgentCount = value.urgentCount ?? 0;
+        const urgentSeqs = value.queue.slice(0, urgentCount).map((entry) => entry.receivedSeq);
+        const backgroundSeqs = value.queue.slice(urgentCount).map((entry) => entry.receivedSeq);
+        const isAscending = (seqs) => seqs.every((seq, index) => index === 0 || seq > seqs[index - 1]);
+        if (!isAscending(urgentSeqs) || !isAscending(backgroundSeqs))
+            throw new Error('INVALID_FACT_INBOX_SNAPSHOT');
         if (value.nextSeq <= maxReceivedSeq)
             throw new Error('INVALID_FACT_INBOX_SNAPSHOT');
         for (const [eventId, receivedSeq] of seen)
             inbox.seen.set(eventId, receivedSeq);
         inbox.nextSeq = value.nextSeq;
+        inbox.urgentCount = urgentCount;
         return inbox;
     }
-    clear() { this.queue.length = 0; }
+    clear() { this.queue.length = 0; this.urgentCount = 0; }
 }
 export class ObservationInbox {
     maxEntries;

package/dist/core/mutations.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeEventInput, RuntimeState, RuntimeError, ContextVersion, JsonValue, AgentRecord, LaneRecord, EffectRecord, WaitRecord, ResultRecord, FindingRecord, ArtifactRecord, LaneId, WaitId, EffectId, HistoryRecord, MergeProposal, ToolCallCorrelation, PrivacyMetadata } from './types.js';
+import type { RuntimeEventInput, RuntimeState, RuntimeError, ContextVersion, JsonValue, AgentRecord, LaneRecord, EffectRecord, WaitRecord, ResultRecord, FindingRecord, ArtifactRecord, LaneId, WaitId, EffectId, HistoryRecord, MergeProposal, ToolCallCorrelation, PrivacyMetadata, HumanInputRecord } from './types.js';
 export type Mutation = {
     op: 'setAgent';
     agentId: string;
@@ -36,6 +36,10 @@ export type Mutation = {
 } | {
     op: 'setToolCallCorrelation';
     record: ToolCallCorrelation;
+} | {
+    op: 'setHumanInput';
+    inputId: string;
+    record: HumanInputRecord;
 } | {
     op: 'insertMergeProposal';
     proposal: MergeProposal;

package/dist/core/mutations.js

@@ -21,7 +21,7 @@ export function forkRuntimeStateForAdmission(state, mutations) {
     for (const id of dirtyLanes) {
         const lane = lanes.get(id);
         if (lane)
-            lanes.set(id, { ...lane, ...(lane.visibleResultRefs === undefined ? {} : { visibleResultRefs: new Set(lane.visibleResultRefs) }) });
+            lanes.set(id, { ...lane, ...(lane.visibleResultRefs === undefined ? {} : { visibleResultRefs: new Set(lane.visibleResultRefs) }), ...(lane.pendingHumanInputs === undefined ? {} : { pendingHumanInputs: structuredClone(lane.pendingHumanInputs) }) });
     }
     return {
         ...state,
@@ -33,6 +33,7 @@ export function forkRuntimeStateForAdmission(state, mutations) {
         artifacts: new Map(state.artifacts),
         toolCallCorrelations: new Map(state.toolCallCorrelations),
         mergeProposals: new Map(state.mergeProposals),
+        humanInputs: new Map(state.humanInputs),
         events: state.events.slice(),
         nextIds: { ...state.nextIds },
         trustedSanitizerIds: new Set(state.trustedSanitizerIds),
@@ -91,6 +92,9 @@ export function apply(state, mutations, defaults = {}) {
             case 'setToolCallCorrelation':
                 state.toolCallCorrelations.set(mutation.record.toolCallId, mutation.record);
                 break;
+            case 'setHumanInput':
+                state.humanInputs.set(mutation.inputId, mutation.record);
+                break;
             case 'insertMergeProposal':
                 state.mergeProposals.set(mutation.proposal.id, mutation.proposal);
                 break;

package/dist/core/types.d.ts

@@ -123,6 +123,8 @@ export interface LaneRecord {
     resume: ResumePoint;
     series?: SeriesLaneSpec;
     pendingResumeInput?: ResumeInput;
+    /** Human messages steered into this lane while it was executing or waiting. */
+    pendingHumanInputs?: HumanInputRecord[];
     /** Control proposals that arrived while another ResumeInput occupied the slot. */
     pendingControlProposals?: ControlProposal[];
     contextSnapshotVersion: ContextVersion;
@@ -319,6 +321,9 @@ export type ResumeInput = {
 } | {
     type: 'submitted';
     targets: Record<string, TargetRef>;
+} | {
+    type: 'human';
+    input: HumanInputRecord;
 } | {
     type: 'control_error';
     error: RuntimeError;
@@ -499,14 +504,19 @@ export interface LLMContextSpec {
     eventIds: string[];
     toolSetId: string;
     instruction: string;
+    conversation?: ConversationMessage[];
     privacy: PrivacyLabel;
     privacyRefs: ProvenanceRef[];
     privacyTaints?: PrivacyTaint[];
 }
+export interface ConversationMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
 export interface LLMRequestProjection {
     contextSpec: LLMContextSpec;
     blocks: Array<{
-        kind: 'system' | 'policy' | 'tools' | 'global' | 'history' | 'lane' | 'events' | 'results' | 'artifacts' | 'instruction';
+        kind: 'system' | 'policy' | 'tools' | 'global' | 'conversation' | 'history' | 'lane' | 'events' | 'results' | 'artifacts' | 'instruction';
         content: JsonValue;
     }>;
     prefixHash: string;
@@ -559,6 +569,7 @@ export interface RuntimeState {
     artifacts: Map<ArtifactRef, ArtifactRecord>;
     toolCallCorrelations: Map<string, ToolCallCorrelation>;
     mergeProposals: Map<string, MergeProposal>;
+    humanInputs: Map<string, HumanInputRecord>;
     events: RuntimeEvent[];
     eventsCompactedThrough?: number;
     nextIds: {
@@ -598,6 +609,20 @@ export interface ToolCallCorrelation {
     toolEffectId: EffectId;
     resultRef?: ResultRef;
 }
+/** Durable external input accepted while other Effects are still running. */
+export interface HumanInputRecord {
+    id: string;
+    agentId: AgentId;
+    value: JsonValue;
+    receivedAt: number;
+    status: 'pending' | 'consumed' | 'deferred';
+    targetEffectId?: EffectId;
+    handledByLaneId?: LaneId;
+    decision?: 'respond' | 'steer' | 'spawn' | 'defer' | 'cancel';
+    decisionReason?: string;
+    decisionModelId?: string;
+    decidedAt?: number;
+}
 export declare function createRuntimeState(maxTotalLanes?: number, options?: {
     maxQueuedEffects?: number;
     maxRunning?: Partial<Record<ConcurrencyClass, number>>;

package/dist/core/types.js

@@ -84,7 +84,7 @@ export function privacyTaintsForDerivedRefs(state, lane, refs) {
     return output;
 }
 export function createRuntimeState(maxTotalLanes = 64, options = {}) {
-    return { now: 0, agents: new Map(), lanes: new Map(), effects: new Map(), waits: new Map(), results: new Map(), artifacts: new Map(), toolCallCorrelations: new Map(), mergeProposals: new Map(), events: [], nextIds: { agent: 1, lane: 1, effect: 1, wait: 1, result: 1, artifact: 1, proposal: 1, event: 1 }, maxTotalLanes, maxQueuedEffects: options.maxQueuedEffects ?? 256, maxRunning: { llm: 4, tool: 16, agent: 4, none: Number.POSITIVE_INFINITY, ...(options.maxRunning ?? {}) }, forkAffinity: options.forkAffinity ?? 'advise', historySoftTokens: options.historySoftTokens ?? 8_000, historyHardTokens: options.historyHardTokens ?? 16_000, maxResultSummaryBytes: options.maxResultSummaryBytes ?? 4_096, trustedSanitizerIds: new Set(options.trustedSanitizerIds ?? []) };
+    return { now: 0, agents: new Map(), lanes: new Map(), effects: new Map(), waits: new Map(), results: new Map(), artifacts: new Map(), toolCallCorrelations: new Map(), mergeProposals: new Map(), humanInputs: new Map(), events: [], nextIds: { agent: 1, lane: 1, effect: 1, wait: 1, result: 1, artifact: 1, proposal: 1, event: 1 }, maxTotalLanes, maxQueuedEffects: options.maxQueuedEffects ?? 256, maxRunning: { llm: 4, tool: 16, agent: 4, none: Number.POSITIVE_INFINITY, ...(options.maxRunning ?? {}) }, forkAffinity: options.forkAffinity ?? 'advise', historySoftTokens: options.historySoftTokens ?? 8_000, historyHardTokens: options.historyHardTokens ?? 16_000, maxResultSummaryBytes: options.maxResultSummaryBytes ?? 4_096, trustedSanitizerIds: new Set(options.trustedSanitizerIds ?? []) };
 }
 export function privacyRank(label) { return label === 'public' ? 0 : label === 'cloud_allowed' ? 1 : 2; }
 export function strictestPrivacy(labels) { return labels.reduce((current, next) => privacyRank(next) > privacyRank(current) ? next : current, 'public'); }

package/dist/dsl/program.d.ts

@@ -1,6 +1,6 @@
 import { z, type ZodTypeAny } from 'zod';
 import type { LaneProgram } from '../scheduler/runtime.js';
-import type { ContextDelta, JsonValue, LaneRecord, ResultRef, ProvenanceRef, RuntimeAction, ResumeInput, ProgressWatchdogState, ContextOp, LaneId, PrivacyLabel, RuntimeError, MergeProposal, ResourceLockSpec, Outcome, WaitResolution } from '../core/types.js';
+import type { ContextDelta, ConversationMessage, JsonValue, LaneRecord, ResultRef, ProvenanceRef, RuntimeAction, ResumeInput, ProgressWatchdogState, ContextOp, LaneId, PrivacyLabel, RuntimeError, MergeProposal, ResourceLockSpec, Outcome, WaitResolution, HumanInputRecord } from '../core/types.js';
 import type { ProgramRef } from './templates.js';
 import type { RuntimeToolDiscoveryQuery } from '../tools/registry.js';
 export type NextStepTarget<TState = unknown> = string | {
@@ -33,11 +33,13 @@ export interface StepInputs {
     findings?: ResultRef[];
     artifacts?: string[];
     events?: string[];
+    conversation?: ConversationMessage[];
     toolDiscovery?: RuntimeToolDiscoveryQuery;
 }
 export interface HistoryCompactionOptions {
     summarizeTask: string;
     keepRecentRounds: number;
+    instruction?: string;
 }
 export interface HistoryRecordMeta {
     seq: number;
@@ -76,6 +78,7 @@ export interface StepContext<TState = JsonValue> {
     now: number;
     watchdog?: ProgressWatchdogState;
     resumeInput?: ResumeInput;
+    humanInputs?: readonly HumanInputRecord[];
     results: {
         meta(ref: ResultRef): ResultMeta | undefined;
         summary(ref: ResultRef): JsonValue | undefined;