@roj-ai/sdk 0.1.34 → 0.1.36

package/src/core/sessions/session-overrides.integration.test.ts

@@ -0,0 +1,210 @@
+import { describe, expect, it } from 'bun:test'
+import { ORCHESTRATOR_ROLE } from '~/core/agents/agent-roles.js'
+import { MockLLMProvider } from '~/core/llm/mock.js'
+import { ModelId } from '~/core/llm/schema.js'
+import { createTestPreset, TestHarness } from '~/testing/index.js'
+
+const LUNA = ModelId('openai/gpt-5.6-luna')
+const KIMI = ModelId('moonshotai/kimi-k3')
+
+/** Models the mock provider was actually asked for, in call order. */
+const modelsUsed = (llmProvider: MockLLMProvider): string[] => llmProvider.getCallHistory().map(request => String(request.model))
+
+const newHarness = () =>
+	new TestHarness({
+		presets: [createTestPreset({ agents: [{ name: 'worker', system: 'worker' }] })],
+		llmProvider: MockLLMProvider.withFixedResponse({ content: 'ok', toolCalls: [] }),
+	})
+
+describe('session overrides', () => {
+	it('uses the preset model when no override is set', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test')
+
+		await session.sendAndWaitForIdle('hello')
+
+		expect(modelsUsed(harness.llmProvider)).toEqual(['mock'])
+
+		await harness.shutdown()
+	})
+
+	it('applies an override seeded at session creation', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test', {
+			overrides: { agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
+		})
+
+		await session.sendAndWaitForIdle('hello')
+
+		expect(modelsUsed(harness.llmProvider)).toEqual([String(LUNA)])
+
+		await harness.shutdown()
+	})
+
+	// The point of resolving the model per inference instead of freezing it on the
+	// Agent at construction: this agent is already built and has already run a turn.
+	it('applies an override set at runtime to an already-running agent', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test')
+
+		await session.sendAndWaitForIdle('before')
+		await session.setOverrides({ agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } })
+		await session.sendAndWaitForIdle('after')
+
+		expect(modelsUsed(harness.llmProvider)).toEqual(['mock', String(LUNA)])
+
+		await harness.shutdown()
+	})
+
+	it('reverts to the preset model when an override is cleared with null', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test', {
+			overrides: { agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
+		})
+
+		await session.sendAndWaitForIdle('before')
+		await session.setOverrides({ agents: { [ORCHESTRATOR_ROLE]: null } })
+		await session.sendAndWaitForIdle('after')
+
+		expect(modelsUsed(harness.llmProvider)).toEqual([String(LUNA), 'mock'])
+
+		await harness.shutdown()
+	})
+
+	it('falls back to defaults for an agent with no entry of its own', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test', { overrides: { defaults: { model: KIMI } } })
+
+		await session.sendAndWaitForIdle('hello')
+
+		expect(modelsUsed(harness.llmProvider)).toEqual([String(KIMI)])
+
+		await harness.shutdown()
+	})
+
+	it('lets a per-agent entry win over defaults', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test', {
+			overrides: { defaults: { model: KIMI }, agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
+		})
+
+		await session.sendAndWaitForIdle('hello')
+
+		expect(modelsUsed(harness.llmProvider)).toEqual([String(LUNA)])
+
+		await harness.shutdown()
+	})
+
+	it('leaves defaults alone when a patch only touches agents', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test', { overrides: { defaults: { model: KIMI } } })
+
+		await session.setOverrides({ agents: { worker: { model: LUNA } } })
+		await session.sendAndWaitForIdle('hello')
+
+		// The orchestrator still resolves through the untouched defaults.
+		expect(modelsUsed(harness.llmProvider)).toEqual([String(KIMI)])
+
+		await harness.shutdown()
+	})
+
+	it('rejects an override targeting an agent the preset does not define', async () => {
+		const harness = newHarness()
+
+		const result = await harness.createSessionResult('test', {
+			overrides: { agents: { 'no-such-agent': { model: LUNA } } },
+		})
+
+		expect(result.ok).toBe(false)
+		if (!result.ok) {
+			expect(result.error.message).toContain('no-such-agent')
+		}
+
+		await harness.shutdown()
+	})
+
+	// The RPC surface the worker actually calls.
+	describe('sessions.setOverrides', () => {
+		it('sets the override and echoes back the resolved state', async () => {
+			const harness = newHarness()
+			const session = await harness.createSession('test')
+
+			const result = await harness.sessionManager.callManagerMethod('sessions.setOverrides', {
+				sessionId: String(session.sessionId),
+				overrides: { agents: { worker: { model: LUNA } }, defaults: { model: KIMI } },
+			})
+
+			expect(result.ok).toBe(true)
+			if (result.ok) {
+				expect(result.value).toEqual({
+					agents: { worker: { model: LUNA } },
+					defaults: { model: KIMI },
+				})
+			}
+
+			await harness.shutdown()
+		})
+
+		it('rejects an unknown agent name and names what the preset defines', async () => {
+			const harness = newHarness()
+			const session = await harness.createSession('test')
+
+			const result = await harness.sessionManager.callManagerMethod('sessions.setOverrides', {
+				sessionId: String(session.sessionId),
+				overrides: { agents: { wrker: { model: LUNA } } },
+			})
+
+			expect(result.ok).toBe(false)
+			if (!result.ok) {
+				expect(result.error.message).toContain('wrker')
+				expect(result.error.message).toContain('worker')
+			}
+
+			await harness.shutdown()
+		})
+
+		it('reports the effective overrides back through sessions.get', async () => {
+			const harness = newHarness()
+			const session = await harness.createSession('test', {
+				overrides: { agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
+			})
+
+			const result = await harness.sessionManager.callPluginMethod(
+				session.sessionId,
+				'sessions.get',
+				{ sessionId: String(session.sessionId) },
+			)
+
+			expect(result.ok).toBe(true)
+			if (result.ok) {
+				expect(result.value).toMatchObject({
+					overrides: { agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
+				})
+			}
+
+			await harness.shutdown()
+		})
+	})
+
+	// Overrides are state like any other, so they must survive a replay rather than
+	// living only on the in-memory Session that happened to accept the patch.
+	it('reconstructs overrides when the session is reopened from the event store', async () => {
+		const harness = newHarness()
+		const session = await harness.createSession('test')
+		await session.setOverrides({ agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } })
+		await harness.shutdown()
+
+		const restarted = new TestHarness({
+			presets: [createTestPreset({ agents: [{ name: 'worker', system: 'worker' }] })],
+			llmProvider: MockLLMProvider.withFixedResponse({ content: 'ok', toolCalls: [] }),
+			eventStore: harness.eventStore,
+		})
+		const reopened = await restarted.openSession(session.sessionId)
+
+		await reopened.sendAndWaitForIdle('hello')
+
+		expect(modelsUsed(restarted.llmProvider)).toEqual([String(LUNA)])
+
+		await restarted.shutdown()
+	})
+})

package/src/core/sessions/session.ts

@@ -22,7 +22,7 @@ import type { AgentPluginConfig, BaseSessionHookContext, CallerContext, Configur
 import { AGENT_CALLER, DEFAULT_CALLER, buildPluginDeps, type PluginNotification } from '~/core/plugins/plugin-builder.js'
 import type { Preset } from '~/core/preset/index.js'
 import type { SessionId } from '~/core/sessions/schema.js'
-import type { SessionState } from '~/core/sessions/state.js'
+import type { SessionOverridesPatch, SessionState } from '~/core/sessions/state.js'
 import { getEntryAgentId, getNextAgentSeq, sessionEvents } from '~/core/sessions/state.js'
 import type { Logger } from '~/lib/logger/logger.js'
 import type { Platform } from '~/platform/index.js'
@@ -214,6 +214,24 @@ export class Session {
 		return Ok(undefined)
 	}
 
+	/**
+	 * Patch the session's overrides (see {@link SessionOverrides}).
+	 *
+	 * Takes effect on the next inference each affected agent runs — running agents
+	 * are not rebuilt and a request already in flight completes on the model it
+	 * started with. Callers are expected to have validated the patch against the
+	 * preset; see `unknownOverrideTargets`.
+	 */
+	async setOverrides(patch: SessionOverridesPatch): Promise<Result<void, DomainError>> {
+		if (this.store.isClosed()) {
+			return Err(SessionErrors.closed(String(this.id)))
+		}
+
+		await this.store.emit(withSessionId(this.id, sessionEvents.create('session_overrides_set', patch)))
+
+		return Ok(undefined)
+	}
+
 	/**
 	 * Get an agent by ID.
 	 */

package/src/core/sessions/state.ts

@@ -6,6 +6,7 @@ import { agentEvents } from '~/core/agents/state.js'
 import { contextEvents } from '~/core/context/state.js'
 import { createEventsFactory } from '~/core/events/types'
 import type { DomainEvent } from '~/core/events/types.js'
+import { modelIdSchema } from '~/core/llm/schema.js'
 import { llmEvents } from '~/core/llm/state.js'
 import { SessionId, sessionIdSchema } from '~/core/sessions/schema.js'
 import type { PendingToolResult } from '~/core/tools/schema.js'
@@ -24,6 +25,65 @@ import { createTypedReducer } from './reducer.js'
  */
 export type SessionHandlerName = 'onSessionReady' | 'onSessionClose'
 
+// ============================================================================
+// Session overrides
+// ============================================================================
+
+/**
+ * Per-agent settings layered over the preset definition.
+ *
+ * Deliberately an object rather than a bare model id: the same layering is where
+ * `cacheTtl`, token caps or reasoning effort belong once they need to be
+ * session-scoped, and adding a field here stays backwards compatible.
+ */
+export const agentOverridesSchema = z4.object({
+	/** Replaces the model declared on the agent definition. */
+	model: modelIdSchema.optional(),
+})
+
+export type AgentOverrides = z4.infer<typeof agentOverridesSchema>
+
+/**
+ * A patch against {@link SessionOverrides}. An absent key is left alone, `null`
+ * clears it, and an object replaces that entry wholesale (it is not merged into
+ * the previous value — the entry *is* the override).
+ */
+export const sessionOverridesPatchSchema = z4.object({
+	defaults: agentOverridesSchema.nullable().optional(),
+	agents: z4.record(z4.string(), agentOverridesSchema.nullable()).optional(),
+})
+
+export type SessionOverridesPatch = z4.infer<typeof sessionOverridesPatchSchema>
+
+/**
+ * Session-scoped configuration layered over the preset, patchable at any time.
+ *
+ * Two levels because they answer different questions. `defaults` is "run this
+ * whole session on X"; `agents` is "…except this one". A preset that pins a
+ * cheap model to specific sub-agents (redo's `fastModel`) would have that intent
+ * flattened by `defaults` alone, so the per-definition level is what makes the
+ * override surgical.
+ */
+export interface SessionOverrides {
+	/** Applied to every agent that has no `agents` entry. */
+	defaults?: AgentOverrides
+	/** Keyed by definitionName, including ORCHESTRATOR_ROLE / COMMUNICATOR_ROLE. */
+	agents: Map<string, AgentOverrides>
+}
+
+/**
+ * Effective overrides for one agent definition: `agents` layered over `defaults`
+ * field by field, so `defaults: { model }` plus a per-agent entry that only sets
+ * some other field keeps the default model.
+ */
+export const resolveAgentOverrides = (
+	state: SessionState,
+	definitionName: string,
+): AgentOverrides => ({
+	...state.overrides.defaults,
+	...state.overrides.agents.get(definitionName),
+})
+
 export const sessionEvents = createEventsFactory({
 	events: {
 		session_created: z4.object({
@@ -44,6 +104,7 @@ export const sessionEvents = createEventsFactory({
 			key: z4.string(),
 			value: z4.unknown(),
 		}),
+		session_overrides_set: sessionOverridesPatchSchema,
 		session_handler_started: z4.object({
 			handlerName: z4.enum(['onSessionReady', 'onSessionClose']),
 			pluginName: z4.string(),
@@ -62,6 +123,7 @@ export type SessionClosedEvent = (typeof sessionEvents)['Events']['session_close
 export type SessionReopenedEvent = (typeof sessionEvents)['Events']['session_reopened']
 export type SessionRestartedEvent = (typeof sessionEvents)['Events']['session_restarted']
 export type SessionMetadataSetEvent = (typeof sessionEvents)['Events']['session_metadata_set']
+export type SessionOverridesSetEvent = (typeof sessionEvents)['Events']['session_overrides_set']
 export type SessionHandlerStartedEvent = (typeof sessionEvents)['Events']['session_handler_started']
 export type SessionHandlerCompletedEvent = (typeof sessionEvents)['Events']['session_handler_completed']
 
@@ -89,6 +151,8 @@ export interface SessionState {
 	workspaceDir?: string
 	/** Generic key-value metadata store (tool sets use their own keys) */
 	metadata: Map<string, unknown>
+	/** Session-scoped settings layered over the preset. See {@link SessionOverrides}. */
+	overrides: SessionOverrides
 	/** If this session was forked from another session */
 	forkedFrom?: { sessionId: SessionId; eventIndex: number }
 }
@@ -109,6 +173,7 @@ export const createSessionState = (
 	createdAt: timestamp,
 	agentCounters: new Map(),
 	metadata: new Map(),
+	overrides: { agents: new Map() },
 })
 
 // ============================================================================
@@ -195,6 +260,8 @@ export const coreReducer = createTypedReducer(
 					role: 'assistant',
 					content: event.response.content ?? '',
 					toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+					reasoningDetails: event.response.reasoningDetails,
+					thinkingBlocks: event.response.thinkingBlocks,
 				}
 
 				return updateAgent(state, event.agentId, (agent) => {
@@ -309,6 +376,9 @@ export const coreReducer = createTypedReducer(
 									role: 'assistant',
 									content: m.content,
 									toolCalls: m.toolCalls,
+									// Survives compaction: a retained turn keeps the reasoning the provider wants echoed back.
+									reasoningDetails: m.reasoningDetails,
+									thinkingBlocks: m.thinkingBlocks,
 									cacheControl: m.cacheControl,
 								}
 							case 'tool':
@@ -429,6 +499,18 @@ export const coreReducer = createTypedReducer(
 				return { ...state, metadata: newMetadata }
 			}
 
+			case 'session_overrides_set': {
+				const agents = new Map(state.overrides.agents)
+				for (const [definitionName, override] of Object.entries(event.agents ?? {})) {
+					if (override === null) agents.delete(definitionName)
+					else agents.set(definitionName, override)
+				}
+				// undefined = untouched, null = cleared. `?? undefined` collapses the
+				// explicit null, which the state shape does not carry.
+				const defaults = event.defaults === undefined ? state.overrides.defaults : (event.defaults ?? undefined)
+				return { ...state, overrides: { defaults, agents } }
+			}
+
 			case 'agent_paused':
 				return updateAgent(state, event.agentId, (agent) => ({
 					...agent,

package/src/index.ts

@@ -58,6 +58,7 @@ export type { ChatMessageContentItem, LLMCallLogEntry, LLMCallMessage, ToolResul
 export { contentToString } from '~/core/llm/llm-log-types.js'
 export { applyMiddleware, useProvider, withAnthropic, withMaxTokens, withOpenRouter, withTemperature } from '~/core/llm/middleware.js'
 export type { InferenceNext, LLMMiddleware } from '~/core/llm/middleware.js'
+export type { OpenRouterProviderRouting, OpenRouterReasoningOptions, OpenRouterRequestOptions } from '~/core/llm/provider.js'
 export { ModelId } from '~/core/llm/schema.js'
 export type { LLMCallId } from '~/core/llm/schema.js'
 export type { InferenceCompletedEvent, InferenceFailedEvent, InferenceStartedEvent } from '~/core/llm/state.js'
@@ -66,7 +67,14 @@ export { applyEvent } from '~/core/sessions/apply-event.js'
 export { selectPluginState } from '~/core/sessions/reducer.js'
 export { SessionId } from '~/core/sessions/schema.js'
 export type { SessionMetadata } from '~/core/sessions/schema.js'
-export { createSessionState, reconstructSessionState } from '~/core/sessions/state.js'
+export type { AgentOverrides, SessionOverrides, SessionOverridesPatch } from '~/core/sessions/state.js'
+export {
+	agentOverridesSchema,
+	createSessionState,
+	reconstructSessionState,
+	resolveAgentOverrides,
+	sessionOverridesPatchSchema,
+} from '~/core/sessions/state.js'
 export type { SessionState } from '~/core/sessions/state.js'
 export type { ToolCallId } from '~/core/tools/schema.js'
 export type { ToolStartedEvent } from '~/core/tools/state.js'

package/src/plugins/services/plugin.ts

@@ -22,6 +22,14 @@ export const serviceEvents = createEventsFactory({
 			command: z.string().optional(),
 			pid: z.number().optional(),
 			pidStartTime: z.number().optional(),
+			/**
+			 * Set on a `failed` change when the `restartPolicy` has already queued a
+			 * revival, so that no consumer — agent prompt, SPA, platform — mistakes it
+			 * for a terminal failure. Cleared by the next status change.
+			 */
+			restartAt: z.number().optional(),
+			restartAttempt: z.number().optional(),
+			restartMaxRetries: z.number().optional(),
 		}),
 	},
 })
@@ -73,6 +81,10 @@ export const servicePlugin = definePlugin('services')
 						const updated: ServiceEntry = {
 							...existing,
 							status: event.toStatus,
+							// A queued revival lives only until the next status change.
+							restartAt: event.restartAt,
+							restartAttempt: event.restartAttempt,
+							restartMaxRetries: event.restartMaxRetries,
 						}
 						if (event.toStatus === 'starting') {
 							updated.startedAt = event.timestamp
@@ -115,17 +127,25 @@ export const servicePlugin = definePlugin('services')
 					let changed = false
 					const newServices = new Map(services)
 					for (const [serviceType, entry] of services) {
-						if (entry.status === 'starting' || entry.status === 'ready') {
-							newServices.set(serviceType, {
-								...entry,
-								status: 'stopped',
-								port: undefined,
-								pid: undefined,
-								pidStartTime: undefined,
-								stoppedAt: event.timestamp,
-							})
-							changed = true
+						const running = entry.status === 'starting' || entry.status === 'ready'
+						// Any queued revival died with the runtime that held its timer.
+						if (!running && entry.restartAt === undefined) continue
+
+						const updated: ServiceEntry = {
+							...entry,
+							restartAt: undefined,
+							restartAttempt: undefined,
+							restartMaxRetries: undefined,
+						}
+						if (running) {
+							updated.status = 'stopped'
+							updated.port = undefined
+							updated.pid = undefined
+							updated.pidStartTime = undefined
+							updated.stoppedAt = event.timestamp
 						}
+						newServices.set(serviceType, updated)
+						changed = true
 					}
 					return changed ? newServices : services
 				}
@@ -151,9 +171,22 @@ export const servicePlugin = definePlugin('services')
 				command: details.command,
 				pid: details.pid,
 				pidStartTime: details.pidStartTime,
+				restartAt: details.restartAt,
+				restartAttempt: details.restartAttempt,
+				restartMaxRetries: details.restartMaxRetries,
 			}))
-			// Broadcast service status to connected clients (DO → SPA) via WS
-			ctx.notify('serviceStatus', { sessionId: String(sessionId), serviceType, status, port: details.port })
+			// Broadcast service status to connected clients (DO → SPA) via WS.
+			// restartAt rides along so a consumer can hold on to a preview URL it
+			// would otherwise tear down on `failed`.
+			ctx.notify('serviceStatus', {
+				sessionId: String(sessionId),
+				serviceType,
+				status,
+				port: details.port,
+				restartAt: details.restartAt,
+				restartAttempt: details.restartAttempt,
+				restartMaxRetries: details.restartMaxRetries,
+			})
 		}
 		return { executor }
 	})
@@ -378,7 +411,10 @@ export const servicePlugin = definePlugin('services')
 	.sessionHook('onSessionClose', async (ctx) => {
 		for (const svcConfig of ctx.pluginConfig.services) {
 			const status = ctx.pluginContext.executor.getStatus(svcConfig.type)
-			if (status === 'ready' || status === 'starting') {
+			// A queued revival outlives the session otherwise: its timer holds the
+			// executor alive and spawns a process into a session that is already gone.
+			const revivalQueued = ctx.pluginContext.executor.hasScheduledRestart(svcConfig.type)
+			if (status === 'ready' || status === 'starting' || revivalQueued) {
 				await ctx.pluginContext.executor.stop(svcConfig.type, ctx.sessionId)
 			}
 		}
@@ -395,7 +431,7 @@ export const servicePlugin = definePlugin('services')
 			createTool({
 				name: 'service_start',
 				description:
-					`Start a stopped or failed session service. Only call this if the session context shows the service is not running — if it is already "ready", you do not need to start it. Available services: ${serviceList}`,
+					`Start a stopped or failed session service. Only call this if the session context shows the service is not running — if it is already "ready", or marked as restarting automatically, you do not need to start it. Available services: ${serviceList}`,
 				input: z.object({
 					serviceType: z.string().describe('Service type identifier'),
 				}),

package/src/plugins/services/prompt.ts

@@ -42,6 +42,14 @@ export function buildServiceStatusMessage(
 		if (entry?.error) {
 			line += ` (error: ${entry.error})`
 		}
+		// A queued revival means the service comes back on its own — say so, or the
+		// agent burns a turn restarting by hand what was about to restart anyway.
+		if (entry?.restartAt !== undefined) {
+			const attempt = entry.restartAttempt !== undefined && entry.restartMaxRetries !== undefined
+				? ` (attempt ${entry.restartAttempt}/${entry.restartMaxRetries})`
+				: ''
+			line += ` — restarting automatically${attempt}, no action needed`
+		}
 		// Deliberately no cwd: it is a real host path, while sandboxed agents see the
 		// world through virtual roots — leaking it sends them chasing paths that
 		// don't exist in their namespace (see webmaster path-identity incident).

package/src/plugins/services/schema.ts

@@ -101,6 +101,28 @@ export interface ServiceConfig {
 	logBufferSize?: number
 	/** Startup timeout in ms — service marked as failed if not ready within this time (default: 30000) */
 	startupTimeoutMs?: number
+	/**
+	 * Bring the service back after an unexpected exit, on the port it already
+	 * holds. Omitted means what has always happened: the service is left
+	 * `failed` and waits for someone to call restart.
+	 *
+	 * For a long-running service nobody is watching — a dev server behind a
+	 * preview URL — a crash otherwise means the URL stays dead until a human
+	 * or an agent notices. The retry budget is per consecutive failure and
+	 * resets once the service has stayed up for `healthyAfterMs`, so a process
+	 * that dies repeatedly at startup still ends up `failed` instead of
+	 * looping forever.
+	 */
+	restartPolicy?: {
+		/** Consecutive automatic restarts before giving up (default: 3) */
+		maxRetries?: number
+		/** Delay before the first retry; doubles per attempt (default: 1000) */
+		initialDelayMs?: number
+		/** Ceiling for the doubling (default: 30000) */
+		maxDelayMs?: number
+		/** Uptime that counts as healthy and resets the budget (default: 60000) */
+		healthyAfterMs?: number
+	}
 	/** Auto-pause configuration (interface prepared, not yet implemented) */
 	autoPause?: { inactivityMs: number }
 	/**
@@ -133,6 +155,17 @@ export interface ServiceEntry {
 	startedAt?: number
 	readyAt?: number
 	stoppedAt?: number
+	/**
+	 * When a `restartPolicy` revival is queued, the epoch ms at which it fires.
+	 * Present only while the revival is pending — any later status change clears
+	 * it — so `failed` with `restartAt` set means "down, but coming back on its
+	 * own" and nobody downstream has to treat it as terminal.
+	 */
+	restartAt?: number
+	/** 1-based attempt number of the queued revival. */
+	restartAttempt?: number
+	/** Retry budget the queued revival counts against. */
+	restartMaxRetries?: number
 	/** Process group PID (tracked for orphan cleanup after restart) */
 	pid?: number
 	/**