npm - gestalt-mobile - Versions diffs - 0.25.2 → 0.25.3 - Mend

gestalt-mobile 0.25.2 → 0.25.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/dist/client/index.html CHANGED Viewed

@@ -16,7 +16,7 @@ SPDX-License-Identifier: AGPL-3.0-or-later
     <link rel="icon" href="/icons/gestalt-mobile-192.png" />
     <link rel="apple-touch-icon" href="/icons/gestalt-mobile-180.png" />
     <title>Gestalt Mobile</title>
-    <script type="module" crossorigin src="/assets/index-BkpRh3eb.js"></script>
+    <script type="module" crossorigin src="/assets/index-CFw8G97O.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-D3wXcWGp.css">
   </head>
   <body>

package/dist/server/server/composition.contracts.js CHANGED Viewed

@@ -49,6 +49,9 @@ function liveAppServer(handles) {
                 request: async (method, params) => {
                     handle.calls.push(method);
                     handle.requests.push({ method, params });
+                    const overridden = await handle.respond?.(method, params);
+                    if (overridden !== undefined)
+                        return overridden;
                     if (method === 'thread/start')
                         return { thread: { id: `thread-${handles.length}` } };
                     if (method === 'turn/start')
@@ -363,7 +366,7 @@ describe('production composition', () => {
             expect(messages.filter((message) => message.event.type === 'autopilot.updated').at(-1)?.event
                 .payload).toMatchObject({ enabled: true });
             // This is production composition, not a coordinator fake: the scheduler reaches the
-            // real runtime adapter and can pass only the fixed policy-owned prompt and opaque ID.
+            // real runtime adapter and can pass only policy-owned lifecycle context and an opaque ID.
             await vi.waitFor(() => expect(handles.at(-1)?.calls.filter((call) => call === 'turn/start')).toHaveLength(1), { timeout: 2_500 });
             const automaticStart = handles.at(-1)?.requests.find((call) => call.method === 'turn/start');
             expect(automaticStart?.params).toEqual({
@@ -371,7 +374,7 @@ describe('production composition', () => {
                 input: [
                     {
                         type: 'text',
-                        text: AUTOPILOT_CONTINUATION_PROMPT,
+                        text: `${AUTOPILOT_CONTINUATION_PROMPT} Launch task_name l1 for canonical L1; retain the canonical label in status and review output.`,
                         text_elements: [],
                     },
                 ],
@@ -556,7 +559,7 @@ describe('production composition', () => {
             expect(events.count).toBe(1);
             await fixture.app.close();
         });
-        it('production restart unexplained issued requires attention while issued persisted activeTurn records one started audit without replay', async () => {
+        it('production restart keeps unexplained issued state supervised while persisted activeTurn records one started audit without replay', async () => {
             let coordinator;
             const fixture = await createProductionAutopilotFixture({
                 onAutopilotCoordinator: (value) => {
@@ -577,11 +580,11 @@ describe('production composition', () => {
             database.close();
             coordinator.restore(fixture.sessionId);
             await vi.waitFor(async () => expect((await fixture.app.inject(`/api/sessions/${fixture.sessionId}`)).json()).toMatchObject({
-                autopilot: { enabled: false, state: 'attentionRequired', reason: 'reconcileFailed' },
+                autopilot: { enabled: true, state: 'monitoring', reason: 'reconcileFailed' },
             }));
             expect(fixture.handles.flatMap((handle) => handle.calls)).not.toContain('turn/start');
-            // This coordinator safety stop has no tool request id. Recovery is the
-            // ordinary durable Autopilot toggle, not the attention resolver route.
+            // Re-enabling is idempotent because runtime ambiguity remains under
+            // condition-based supervision rather than becoming synthetic attention.
             expect((await fixture.app.inject({
                 method: 'PUT',
                 url: `/api/sessions/${fixture.sessionId}/autopilot`,
@@ -804,6 +807,37 @@ describe('production composition', () => {
         it('production child-idle transition wakes an idle supervised autopilot', async () => {
             const timers = [];
             const fixture = await createProductionAutopilotFixture({
+                autopilotActivity: (sessionId) => {
+                    const observedAt = new Date().toISOString();
+                    return {
+                        sessionId,
+                        rootThreadId: 'thread-1',
+                        root: {
+                            state: 'idle',
+                            reason: 'turnCompleted',
+                            observedAt,
+                            lastActivityAt: observedAt,
+                        },
+                        subagents: [
+                            {
+                                id: 'child-1',
+                                threadId: 'child-1',
+                                taskPath: '/root/l1',
+                                canonicalTaskName: 'l1',
+                                canonicalPosition: 'L1',
+                                continuationGeneration: 1,
+                                outcome: 'partial',
+                                ownedProcesses: [],
+                                state: 'idle',
+                                reason: 'turnCompleted',
+                                observedAt,
+                                lastActivityAt: observedAt,
+                            },
+                        ],
+                        aggregateSubagents: 'idle',
+                        confidence: 'fresh',
+                    };
+                },
                 autopilotSchedule: (callback) => {
                     const timer = { callback, cancelled: false, fired: false };
                     timers.push(timer);
@@ -818,57 +852,17 @@ describe('production composition', () => {
                 payload: { enabled: false },
             })).statusCode).toBe(200);
             timers.length = 0;
-            const handle = fixture.handles.find((candidate) => candidate.notify);
-            handle.notify({
-                method: 'thread/started',
-                params: { thread: { id: 'thread-1', status: { type: 'active' } } },
-            });
-            handle.notify({
-                method: 'item/started',
-                params: {
-                    item: {
-                        type: 'collabToolCall',
-                        tool: 'spawn_agent',
-                        status: 'inProgress',
-                        senderThreadId: 'thread-1',
-                        receiverThreadId: 'child-1',
-                        agentStatus: 'working',
-                    },
-                },
-            });
-            handle.notify({
-                method: 'thread/status/changed',
-                params: { threadId: 'thread-1', status: { type: 'idle' } },
-            });
             expect((await fixture.app.inject({
                 method: 'PUT',
                 url: `/api/sessions/${fixture.sessionId}/autopilot`,
                 payload: { enabled: true },
             })).statusCode).toBe(200);
-            expect(timers).toHaveLength(0);
-            handle.notify({
-                method: 'item/completed',
-                params: {
-                    item: {
-                        type: 'collabToolCall',
-                        tool: 'wait',
-                        status: 'completed',
-                        senderThreadId: 'thread-1',
-                        receiverThreadId: 'child-1',
-                        agentStatus: 'idle',
-                    },
-                },
-            });
             expect(timers.filter((timer) => !timer.cancelled && !timer.fired)).toHaveLength(1);
-            for (let index = 0; index < 2; index += 1) {
-                const timer = timers.find((candidate) => !candidate.cancelled && !candidate.fired);
-                expect(timer).toBeDefined();
-                timer.fired = true;
-                timer.callback();
-            }
-            await vi.waitFor(() => expect(fixture.handles
-                .flatMap((candidate) => candidate.calls)
-                .filter((call) => call === 'turn/start')).toHaveLength(1));
+            const timer = timers.find((candidate) => !candidate.cancelled && !candidate.fired);
+            timer.fired = true;
+            timer.callback();
+            await vi.waitFor(() => expect(fixture.handles.flatMap((candidate) => candidate.requests.filter((call) => call.method === 'turn/start'))).toHaveLength(1));
+            expect(fixture.handles.flatMap((candidate) => candidate.requests.filter((call) => call.method === 'turn/start'))[0]?.params).toMatchObject({ threadId: 'child-1' });
             await fixture.app.close();
         });
         it('production blocked child wakes the idle supervisor for bounded recovery', async () => {
@@ -929,8 +923,8 @@ describe('production composition', () => {
             expect(quietTimer).toBeDefined();
             quietTimer.fired = true;
             quietTimer.callback();
+            await vi.waitFor(() => expect(timers.find((timer) => !timer.cancelled && !timer.fired)).toBeDefined());
             const continuationTimer = timers.find((timer) => !timer.cancelled && !timer.fired);
-            expect(continuationTimer).toBeDefined();
             continuationTimer.fired = true;
             continuationTimer.callback();
             await vi.waitFor(() => expect(fixture.handles
@@ -938,10 +932,9 @@ describe('production composition', () => {
                 .filter((call) => call === 'turn/start')).toHaveLength(1));
             await fixture.app.close();
         });
-        it('production incompatible exhausted reconcile becomes typed attention with no later reads or timers', async () => {
+        it('production incompatible reconcile remains supervised and schedules reinspection', async () => {
             let reconciliations = 0;
             const timers = [];
-            let coordinator;
             const fixture = await createProductionAutopilotFixture({
                 autopilotActivity: () => null,
                 autopilotReconcile: async () => {
@@ -952,9 +945,6 @@ describe('production composition', () => {
                     timers.push(callback);
                     return () => undefined;
                 },
-                onAutopilotCoordinator: (value) => {
-                    coordinator = value;
-                },
             });
             expect((await fixture.app.inject({
                 method: 'PUT',
@@ -962,14 +952,14 @@ describe('production composition', () => {
                 payload: { enabled: true },
             })).statusCode).toBe(200);
             await vi.waitFor(async () => expect((await fixture.app.inject(`/api/sessions/${fixture.sessionId}`)).json()).toMatchObject({
-                autopilot: { state: 'attentionRequired', enabled: false, reason: 'reconcileFailed' },
+                autopilot: { state: 'monitoring', enabled: true, reason: 'reconcileFailed' },
             }));
             const stableReconciliations = reconciliations;
             const stableTimers = timers.length;
-            coordinator.evaluate(fixture.sessionId);
-            await new Promise((resolve) => setTimeout(resolve, 25));
-            expect(reconciliations).toBe(stableReconciliations);
-            expect(timers).toHaveLength(stableTimers);
+            expect(stableTimers).toBeGreaterThan(0);
+            await timers.at(-1)?.();
+            await vi.waitFor(() => expect(reconciliations).toBeGreaterThan(stableReconciliations));
+            expect(timers.length).toBeGreaterThanOrEqual(stableTimers);
             await fixture.app.close();
         });
         it('production post-acceptance fault recovers one accepted control without a second turn or audit', async () => {

package/dist/server/server/composition.js CHANGED Viewed

@@ -49,7 +49,7 @@ import { checkpointPlanMeasurement } from './platform/plans/plan-measurement-com
 import { PlanMeasurementRefresh } from './platform/plans/plan-measurement-refresh.js';
 import { SqliteAutopilotStore } from './platform/persistence/sqlite-autopilot-store.js';
 import { AutopilotCoordinator } from './features/autopilot/application/service.js';
-import { AUTOPILOT_CONTINUATION_PROMPT, defaultAutopilotPolicy, } from './features/autopilot/application/policy.js';
+import { AUTOPILOT_CONTINUATION_PROMPT, AUTOPILOT_EXECUTOR_CONTINUATION_PROMPT, defaultAutopilotPolicy, } from './features/autopilot/application/policy.js';
 import { createRelyingPartyConfig } from './config.js';
 import { parseOrgPlanAttention } from '../shared/contracts/org-plan-attention.js';
 const generatedProtocolVersion = 'codex-cli 0.144.3';
@@ -144,11 +144,18 @@ export async function composeRelayApp(options) {
                 ...(history.activeTurnId ? { turnId: history.activeTurnId } : {}),
             });
             const children = await runtime.listDirectChildren(session);
+            const childProcesses = new Map();
+            await mapWithConcurrency([...children], 4, async (child) => {
+                childProcesses.set(child.id, await runtime.inspectChildProcesses(session, child));
+            });
             // The writer read is also asynchronous; it cannot publish after the
             // durable owner has gone away either.
             if (!sessions.find(sessionId))
                 return;
-            activity.childrenReconciled(sessionId, occurredAt, children);
+            activity.childrenReconciled(sessionId, occurredAt, children.map((child) => ({
+                ...child,
+                processes: childProcesses.get(child.id) ?? [],
+            })));
         },
     });
     const autopilot = new AutopilotCoordinator({
@@ -165,6 +172,15 @@ export async function composeRelayApp(options) {
             ? options.autopilotActivity(sessionId)
             : activity.snapshot(sessionId, new Date().toISOString()),
         pendingInteraction: (sessionId) => interactions.list(sessionId).length > 0,
+        attention: (sessionId) => {
+            const interaction = interactions
+                .list(sessionId)
+                .find((candidate) => candidate.kind === 'orgPlanAttention');
+            const attention = interaction ? parseOrgPlanAttention(interaction.payload) : null;
+            return attention
+                ? { reason: attention.reason, resumeCondition: attention.resumeCondition }
+                : null;
+        },
         reconcile: async (sessionId) => {
             if (options.autopilotReconcile)
                 return options.autopilotReconcile(sessionId);
@@ -180,7 +196,7 @@ export async function composeRelayApp(options) {
             }),
         nextControlId: (sessionId, generation) => `autopilot-${generation}-${createHash('sha256').update(`${sessionId}:${randomUUID()}`).digest('hex').slice(0, 16)}`,
         turnStarter: {
-            start: async (sessionId, controlId, generation) => {
+            start: async (sessionId, controlId, generation, launchIdentity) => {
                 const current = () => {
                     const state = autopilotStore.find(sessionId);
                     return Boolean(state &&
@@ -200,7 +216,10 @@ export async function composeRelayApp(options) {
                 if (!current() || writer.session.activeTurnId || interactions.list(sessionId).length)
                     throw new Error('AUTOPILOT_START_UNAVAILABLE');
                 await options.autopilotBeforeTurnAccepted?.({ sessionId, controlId });
-                const started = await runtime.startTurn(writer.session, AUTOPILOT_CONTINUATION_PROMPT, controlId, new Date().toISOString());
+                const continuationPrompt = launchIdentity
+                    ? `${AUTOPILOT_CONTINUATION_PROMPT} Launch task_name ${launchIdentity.taskName} for canonical ${launchIdentity.canonicalPosition}; retain the canonical label in status and review output.`
+                    : AUTOPILOT_CONTINUATION_PROMPT;
+                const started = await runtime.startTurn(writer.session, continuationPrompt, controlId, new Date().toISOString());
                 if (!started.activeTurnId)
                     throw new Error('AUTOPILOT_START_UNAVAILABLE');
                 sessions.save(started);
@@ -218,6 +237,46 @@ export async function composeRelayApp(options) {
                 });
             },
         },
+        executorController: {
+            resume: async (sessionId, threadId, generation, trigger) => {
+                const session = sessions.find(sessionId);
+                if (!session || !runtime || interactions.list(sessionId).length)
+                    throw new Error('AUTOPILOT_EXECUTOR_UNAVAILABLE');
+                const writer = await runtime.ensureWriter(session, new Date().toISOString());
+                if (interactions.list(sessionId).length)
+                    throw new Error('AUTOPILOT_EXECUTOR_UNAVAILABLE');
+                const context = trigger.kind === 'processExited'
+                    ? ` Process result ${trigger.resultArtifact} exited and is ready in this executor history.`
+                    : trigger.kind === 'processResourceLimit'
+                        ? ` Process ${trigger.processId} exceeded its explicit resource budget and was terminated; diagnose before retrying.`
+                        : '';
+                const clientId = `autopilot-executor-${generation}-${createHash('sha256')
+                    .update(`${sessionId}:${threadId}:${generation}:${randomUUID()}`)
+                    .digest('hex')
+                    .slice(0, 16)}`;
+                const turnId = await runtime.startExecutorTurn(writer.session, threadId, `${AUTOPILOT_EXECUTOR_CONTINUATION_PROMPT}${context}`, clientId);
+                activity.observe({
+                    sessionId,
+                    occurredAt: new Date().toISOString(),
+                    kind: 'turnStarted',
+                    threadId,
+                    turnId,
+                });
+            },
+            refresh: (sessionId) => activity.refresh(sessionId),
+            transferProcess: (sessionId, threadId, processId) => {
+                activity.transferProcessOwnership(sessionId, threadId, processId, new Date().toISOString());
+            },
+            consumeProcess: (sessionId, threadId, processId) => {
+                runtime?.consumeChildProcessResult(sessionId, threadId, processId);
+            },
+            terminateProcess: async (sessionId, threadId, processId) => {
+                const session = sessions.find(sessionId);
+                return session && runtime
+                    ? runtime.terminateChildProcess(session, threadId, processId)
+                    : false;
+            },
+        },
         publish: (sessionId, type, payload, occurredAt, outboxId) => {
             if (!sessions.find(sessionId))
                 return;

package/dist/server/server/features/agent-activity/model.js CHANGED Viewed

@@ -3,6 +3,7 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+import { parseOrgPlanAgentIdentity } from '../../../shared/org-plan-position.js';
 const states = [
     'blocked',
     'awaitingHuman',
@@ -81,6 +82,9 @@ export function projectAgentActivity(current, fact) {
             root.reason = 'missingCollaborationMetadata';
         else {
             const before = children.get(fact.childId);
+            const taskPath = fact.childTaskPath ?? before?.taskPath;
+            const identity = taskPath ? parseOrgPlanAgentIdentity(taskPath) : null;
+            const outcome = childOutcome(fact.childStatus, fact.collaborationAction, before?.outcome);
             const child = Object.freeze({
                 id: fact.childId,
                 ...(fact.childThreadId
@@ -99,6 +103,20 @@ export function projectAgentActivity(current, fact) {
                     : before?.model
                         ? { model: before.model }
                         : {}),
+                ...(taskPath ? { taskPath } : {}),
+                ...(identity
+                    ? {
+                        canonicalTaskName: identity.canonicalTaskName,
+                        canonicalPosition: identity.canonicalPosition,
+                        continuationGeneration: identity.generation,
+                    }
+                    : {}),
+                ...(outcome ? { outcome } : {}),
+                ...(fact.childOwnedProcesses
+                    ? { ownedProcesses: Object.freeze([...fact.childOwnedProcesses]) }
+                    : before?.ownedProcesses
+                        ? { ownedProcesses: before.ownedProcesses }
+                        : {}),
                 state: childState(fact.childStatus, fact.collaborationAction, before?.state),
                 reason: childReason(fact.childStatus, fact.collaborationAction),
                 observedAt: fact.occurredAt,
@@ -145,6 +163,15 @@ function applyStatus(root, status) {
     else if (status === 'active' || status === 'working')
         Object.assign(root, { state: 'working', reason: 'turnActive' });
 }
+function childOutcome(status, action, previous) {
+    if (status === 'error' || status === 'failed' || status === 'systemError' || status === 'errored')
+        return 'failed';
+    if (status === 'interrupted' || status === 'shutdown' || action === 'close_agent')
+        return 'cancelled';
+    if (status === 'completed' || status === 'idle')
+        return 'partial';
+    return previous;
+}
 function childState(status, action, previous = 'working') {
     if (status === 'error' || status === 'failed' || status === 'systemError' || status === 'errored')
         return 'blocked';

package/dist/server/server/features/agent-activity/registry.js CHANGED Viewed

@@ -91,6 +91,8 @@ export class AgentActivityRegistry {
                 ...(child.nickname ? { childNickname: child.nickname } : {}),
                 ...(child.role ? { childRole: child.role } : {}),
                 ...(child.model ? { childModel: child.model } : {}),
+                ...(child.taskPath ? { childTaskPath: child.taskPath } : {}),
+                ...(child.processes ? { childOwnedProcesses: child.processes } : {}),
             });
         for (const child of next.subagents)
             if (!seen.has(child.id))
@@ -112,6 +114,28 @@ export class AgentActivityRegistry {
         }
         return next;
     }
+    transferProcessOwnership(sessionId, childThreadId, processId, occurredAt) {
+        const current = this.snapshot(sessionId, occurredAt);
+        const child = current.subagents.find((candidate) => candidate.id === childThreadId);
+        if (!child?.ownedProcesses?.some((process) => process.processId === processId))
+            return current;
+        const next = withActivityConfidence(projectAgentActivity(current, {
+            sessionId,
+            occurredAt,
+            kind: 'collaboration',
+            childId: child.id,
+            childThreadId: child.threadId,
+            childTaskPath: child.taskPath,
+            childOwnedProcesses: child.ownedProcesses.map((process) => process.processId === processId
+                ? { ...process, ownership: 'supervisor', state: 'detached-active' }
+                : process),
+        }), 'fresh');
+        if (next !== current) {
+            this.#snapshots.set(sessionId, next);
+            this.publish(next, occurredAt);
+        }
+        return next;
+    }
     dispose(sessionId) {
         this.#disposed.add(sessionId);
         this.#snapshots.delete(sessionId);

package/dist/server/server/features/autopilot/application/policy.js CHANGED Viewed

@@ -3,14 +3,20 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-export const AUTOPILOT_PROMPT_VERSION = 'v2';
+export const AUTOPILOT_PROMPT_VERSION = 'v3';
 export const AUTOPILOT_CONTINUATION_PROMPT = 'Inspect the active supervised Org Plan. Refer to every L1 as L<a> and each nested L2 as L<a>.<b>, using one-based positions. For a subagent dedicated to that position, use the collaboration-safe task_name l<a> or l<a>_<b> and refer to it by its canonical L label. Invoke gestalt_org_plan_attention only for a decision-table blocker; otherwise immediately perform the next legal lifecycle action. Do not send a status-only response.';
+export const AUTOPILOT_EXECUTOR_CONTINUATION_PROMPT = 'Continue the same assigned Org L1 from its durable state. A prior turn ending did not complete the objective. Consume any supplied process result, take the next legal L2 action, and report only at the L1 review boundary or through structured attention.';
 export const defaultAutopilotPolicy = Object.freeze({
     quiescenceMs: 1_000,
     staleAfterMs: 30_000,
     retryLimit: 3,
     actionLimit: 12,
     actionWindowMs: 10 * 60_000,
+    executorContinuationBaseMs: 1_000,
+    executorContinuationMaxMs: 60_000,
+    processPollMs: 1_000,
+    processMaxElapsedMs: 2 * 60 * 60_000,
+    processMaxRssBytes: 12 * 1024 * 1024 * 1024,
     backoffMs: (attempt) => Math.min(60_000, 1_000 * 2 ** Math.max(0, attempt)),
     promptVersion: AUTOPILOT_PROMPT_VERSION,
 });
@@ -39,7 +45,7 @@ export function classifyAgentActivity(activity) {
 /** A deliberately pure, exhaustive safety gate. Adapters may only enact this result. */
 export function decideAutopilot(input) {
     const { state, plan, activity, hasPendingInteraction, now, policy } = input;
-    if (input.hasActiveAttention || state.state === 'attentionRequired')
+    if (input.hasActiveAttention)
         return {
             kind: 'requestAttention',
             reason: state.stopReason === 'noPlanProgress' ||
@@ -55,27 +61,23 @@ export function decideAutopilot(input) {
         return { kind: 'disable', reason: 'planRequired' };
     if (executionComplete(plan))
         return { kind: 'complete' };
+    // Quiz, approval, and other held requests are ordinary session work. Only a
+    // validated Org attention record may turn an incomplete plan into a human stop.
     if (hasPendingInteraction)
-        return { kind: 'requestAttention', reason: 'attentionRequired' };
+        return { kind: 'observe' };
     if (!activity || activity.confidence !== 'fresh')
         return { kind: 'reconcile' };
     if (Date.parse(now) - Date.parse(activity.root.lastActivityAt) > policy.staleAfterMs)
         return { kind: 'reconcile' };
     const disposition = classifyAgentActivity(activity);
     if (disposition === 'attention')
-        return { kind: 'requestAttention', reason: 'attentionRequired' };
+        return { kind: 'observe' };
     if (disposition === 'reconcile')
         return { kind: 'reconcile' };
     if (disposition !== 'settled')
         return { kind: 'observe' };
-    if ((input.automaticActionCount ?? 0) >= policy.actionLimit)
-        return { kind: 'requestAttention', reason: 'actionRateExceeded' };
-    // The outcome is intentionally interpreted only through durable lack of plan
-    // progress: a failed or unknown automatic turn may retry within the same
-    // bounded budget, while a completed turn with no fingerprint change does too.
-    if (state.consecutiveNoProgress >= policy.retryLimit &&
-        ['completed', 'failed', 'unknown', undefined].includes(input.lastTurnOutcome))
-        return { kind: 'requestAttention', reason: 'noPlanProgress' };
+    // Automatic action counts and partial generations pace continuation, but
+    // cannot manufacture a human blocker while durable Org state remains WIP.
     return {
         kind: 'scheduleContinuation',
         at: new Date(Date.parse(now) + policy.backoffMs(state.consecutiveNoProgress)).toISOString(),