- `agent.wait` default: 30s (just the wait). `timeoutMs` param overrides.

- Agent runtime: `agents.defaults.timeoutSeconds` default 172800s (48 hours); enforced in `runEmbeddedAgent` abort timer.

- Cron runtime: isolated agent-turn `timeoutSeconds` is owned by cron. The scheduler starts that timer when execution begins, aborts the underlying run at the configured deadline, then runs bounded cleanup before recording the timeout so a stale child session cannot keep the lane stuck.

- Session liveness diagnostics: with diagnostics enabled, `diagnostics.stuckSessionWarnMs` classifies long `processing` sessions that have no observed reply, tool, status, block, or ACP progress. Active embedded runs, model calls, and tool calls report as `session.long_running`; active work with no recent progress reports as `session.stalled`; `session.stuck` is reserved for recoverable stale session bookkeeping, including idle queued sessions with stale ownerless model/tool activity. Stale session bookkeeping releases the affected session lane immediately after recovery gates pass; stalled embedded runs are abort-drained only after `diagnostics.stuckSessionAbortMs` (default: at least 5 minutes and 3x the warning threshold) so queued work can resume without cutting off merely slow runs. Recovery emits structured requested/completed outcomes, and diagnostic state is marked idle only if the same processing generation is still current. Repeated `session.stuck` diagnostics back off while the session remains unchanged.

- Session liveness diagnostics: with diagnostics enabled, `diagnostics.stuckSessionWarnMs` classifies long `processing` sessions that have no observed reply, tool, status, block, or ACP progress. Active embedded runs, model calls, and tool calls report as `session.long_running`; owned silent model calls also stay `session.long_running` until `diagnostics.stuckSessionAbortMs` so slow or non-streaming providers are not reported as stalled too early. Active work with no recent progress reports as `session.stalled`; owned model calls switch to `session.stalled` at or after the abort threshold, and ownerless stale model/tool activity is not hidden as long-running. `session.stuck` is reserved for recoverable stale session bookkeeping, including idle queued sessions with stale ownerless model/tool activity. Stale session bookkeeping releases the affected session lane immediately after recovery gates pass; stalled embedded runs are abort-drained only after `diagnostics.stuckSessionAbortMs` (default: at least 5 minutes and 3x the warning threshold) so queued work can resume without cutting off merely slow runs. Recovery emits structured requested/completed outcomes, and diagnostic state is marked idle only if the same processing generation is still current. Repeated `session.stuck` diagnostics back off while the session remains unchanged.

- Model idle timeout: OpenClaw aborts a model request when no response chunks arrive before the idle window. `models.providers.<id>.timeoutSeconds` extends this idle watchdog for slow local/self-hosted providers, but it is still bounded by any lower `agents.defaults.timeoutSeconds` or run-specific timeout because those control the whole agent run. Otherwise OpenClaw uses `agents.defaults.timeoutSeconds` when configured, capped at 120s by default. Cron-triggered runs with no explicit model or agent timeout disable the idle watchdog and rely on the cron outer timeout.

- Provider HTTP request timeout: `models.providers.<id>.timeoutSeconds` applies to that provider's model HTTP fetches, including connect, headers, body, SDK request timeout, total guarded-fetch abort handling, and model stream idle watchdog. Use this for slow local/self-hosted providers such as Ollama before raising the whole agent runtime timeout, and keep the agent/runtime timeout at least as high when the model request needs to run longer.

- If commands seem stuck, enable verbose logs and look for "queued for ...ms" lines to confirm the queue is draining.

- If you need queue depth, enable verbose logs and watch for queue timing lines.

- Codex app-server runs that accept a turn and then stop emitting progress are interrupted by the Codex adapter so the active session lane can release instead of waiting for the outer run timeout.

- When diagnostics are enabled, sessions that remain in `processing` past `diagnostics.stuckSessionWarnMs` with no observed reply, tool, status, block, or ACP progress are classified by current activity. Active work logs as `session.long_running`; active work with no recent progress logs as `session.stalled`; `session.stuck` is reserved for recoverable stale session bookkeeping, including idle queued sessions with stale ownerless model/tool activity, and only that path can release the affected session lane so queued work drains. Repeated `session.stuck` diagnostics back off while the session remains unchanged.

- When diagnostics are enabled, sessions that remain in `processing` past `diagnostics.stuckSessionWarnMs` with no observed reply, tool, status, block, or ACP progress are classified by current activity. Active work logs as `session.long_running`; owned silent model calls also stay `session.long_running` until `diagnostics.stuckSessionAbortMs` so slow or non-streaming providers are not reported as stalled too early. Active work with no recent progress logs as `session.stalled`; owned model calls switch to `session.stalled` at or after the abort threshold, and ownerless stale model/tool activity is not hidden as long-running. `session.stuck` is reserved for recoverable stale session bookkeeping, including idle queued sessions with stale ownerless model/tool activity, and only that path can release the affected session lane so queued work drains. Repeated `session.stuck` diagnostics back off while the session remains unchanged.

## Related

OpenClaw classifies sessions by the work it can still observe:

- `session.long_running`: active embedded work, model calls, or tool calls are

still making progress.

still making progress. Owned model calls that stay silent past

`diagnostics.stuckSessionWarnMs` also report as long-running before

`diagnostics.stuckSessionAbortMs` so slow or non-streaming model providers do

not look like stalled gateway sessions while they remain abort-observable.

- `session.stalled`: active work exists, but the active run has not reported

recent progress. Stalled embedded runs stay observe-only at first, then

abort-drain after `diagnostics.stuckSessionAbortMs` with no progress so queued

turns behind the lane can resume. When unset, the abort threshold defaults to

the safer extended window of at least 5 minutes and 3x

recent progress. Owned model calls switch from `session.long_running` to

`session.stalled` at or after `diagnostics.stuckSessionAbortMs`; ownerless

stale model/tool activity is not treated as harmless long-running work.

Stalled embedded runs stay observe-only at first, then abort-drain after

`diagnostics.stuckSessionAbortMs` with no progress so queued turns behind the

lane can resume. When unset, the abort threshold defaults to the safer

extended window of at least 5 minutes and 3x

`diagnostics.stuckSessionWarnMs`.

- `session.stuck`: stale session bookkeeping with no active work, or an idle

queued session with stale ownerless model/tool activity. This releases the

},

},

{

name: "active work without progress",

name: "active model call without progress before abort threshold",

queueDepth: 0,

activity: {

activeWorkKind: "model_call" as const,

hasActiveEmbeddedRun: true,

lastProgressAgeMs: 31_000,

},

expected: {

eventType: "session.long_running",

reason: "active_model_call_without_progress",

classification: "long_running",

activeWorkKind: "model_call",

recoveryEligible: false,

},

},

{

name: "active model call without progress after abort threshold",

queueDepth: 0,

activity: {

activeWorkKind: "model_call" as const,

hasActiveEmbeddedRun: true,

lastProgressAgeMs: 60_000,

},

expected: {

eventType: "session.stalled",

reason: "active_work_without_progress",

queueDepth,

activity,

staleMs: 30_000,

stuckSessionAbortMs: 60_000,

}),

).toEqual(expected);

});

queueDepth: number;

activity: DiagnosticSessionActivitySnapshot;

staleMs: number;

stuckSessionAbortMs?: number;

}): SessionAttentionClassification {

if (params.activity.activeWorkKind) {

const lastProgressAgeMs = params.activity.lastProgressAgeMs ?? 0;

// Idle session with queued work and stale orphaned activity (no active

// embedded owner) should be classified as recoverable stuck state, not as

// stalled active work. This prevents orphaned model_call or tool_call

params.state === "idle" &&

params.queueDepth > 0 &&

params.activity.hasActiveEmbeddedRun !== true &&

(params.activity.lastProgressAgeMs ?? 0) > params.staleMs

lastProgressAgeMs > params.staleMs

) {

return {

eventType: "session.stuck",

if (

params.activity.activeWorkKind === "tool_call" &&

(params.activity.activeToolAgeMs ?? 0) > params.staleMs &&

(params.activity.lastProgressAgeMs ?? 0) > params.staleMs

lastProgressAgeMs > params.staleMs

) {

return {

eventType: "session.stalled",

recoveryEligible: false,

};

}

if ((params.activity.lastProgressAgeMs ?? 0) > params.staleMs) {

if (

params.activity.activeWorkKind === "model_call" &&

params.activity.hasActiveEmbeddedRun === true &&

lastProgressAgeMs > params.staleMs

) {

if (

typeof params.stuckSessionAbortMs === "number" &&

lastProgressAgeMs >= params.stuckSessionAbortMs

) {

return {

eventType: "session.stalled",

reason: "active_work_without_progress",

classification: "stalled_agent_run",

activeWorkKind: params.activity.activeWorkKind,

recoveryEligible: false,

};

}

return {

eventType: "session.long_running",

reason: "active_model_call_without_progress",

classification: "long_running",

activeWorkKind: params.activity.activeWorkKind,

recoveryEligible: false,

};

}

if (lastProgressAgeMs > params.staleMs) {

return {

eventType: "session.stalled",

reason: "active_work_without_progress",

);

});

it("reports silent model calls as long-running before the abort threshold", async () => {

const events: DiagnosticEventPayload[] = [];

const recoverStuckSession = vi.fn();

const stuckSessionWarnMs = 30_000;

const stuckSessionAbortMs = 90_000;

const unsubscribe = onDiagnosticEvent((event) => {

events.push(event);

});

try {

startDiagnosticHeartbeat(

{

diagnostics: {

enabled: true,

stuckSessionWarnMs,

stuckSessionAbortMs,

},

},

{ recoverStuckSession },

);

logSessionStateChange({ sessionId: "s1", sessionKey: "main", state: "processing" });

markDiagnosticEmbeddedRunStarted({ sessionId: "s1", sessionKey: "main" });

markDiagnosticModelStartedForTest({

sessionId: "s1",

sessionKey: "main",

runId: "run-1",

provider: "openai",

model: "gpt-5",

});

vi.advanceTimersByTime(60_000);

} finally {

unsubscribe();

}

expect(events.some((event) => event.type === "session.stalled")).toBe(false);

expectRecordFields(

requireRecord(

events.findLast((event) => event.type === "session.long_running"),

"long-running event",

),

{

classification: "long_running",

reason: "active_model_call_without_progress",

activeWorkKind: "model_call",

lastProgressReason: "model_call:started",

},

);

expect(recoverStuckSession).not.toHaveBeenCalled();

});

it("does not actively abort model calls with recent stream progress", async () => {

const events: DiagnosticEventPayload[] = [];

const recoverStuckSession = vi.fn();

{ sessionId: state.sessionId, sessionKey: state.sessionKey },

Date.now(),

);

const stuckSessionAbortMs =

params.abortThresholdMs ?? resolveStalledEmbeddedRunAbortMs(params.thresholdMs);

const classification = classifySessionAttention({

state: state.state as "idle" | "processing" | "waiting" | undefined,

queueDepth: state.queueDepth,

activity,

staleMs: params.thresholdMs,

stuckSessionAbortMs,

});

const recoveryEligible =

classification.recoveryEligible ||

isActiveAbortRecoveryEligible({

classification,

activity,

ageMs: params.ageMs,

stuckSessionAbortMs:

params.abortThresholdMs ?? resolveStalledEmbeddedRunAbortMs(params.thresholdMs),

stuckSessionAbortMs,

});

// The warning backoff throttles repeated log lines/events only. It must never

// gate recovery: a recovery-eligible session has to return its classification