dag.session_resume_failed

dag.session_resume_failed

Error message

⚠️ Node `${node.id}`: could not resume the prior session — continued with a fresh session, so the earlier context was not restored.${recoveryPointer}

What it means

Non-fatal warning: resuming the node's prior provider session failed, so the node continued with a fresh session and the earlier conversation context was not restored. The log masks the session id (8-char preview) per resumable-artifact policy and may include a recovery pointer to prior artifacts.

Source

Thrown at packages/workflows/src/dag-executor.ts:10642

              output.resumed === false
            ) {
              // By-reference recovery (#1846): the prior session is gone, but prior
              // invocations of this workflow+scope may have left typed artifacts in
              // the stable scope dir. Point at them (paths only — never pasted
              // content) so the lost context is recoverable on demand. Entries from
              // THIS run are excluded — they were produced by the current (fresh)
              // invocation and recover nothing. Best-effort: a scope-dir read
              // failure degrades to the plain warning, never fails the node.
              const recoveryPointer = ctx.scopeArtifactsDir
                ? await buildColdResumeRecoveryPointer(
                    ctx.scopeArtifactsDir,
                    ctx.workflowRun.id,
                    node.id
                  )
                : '';
              // Mask the session id: it's a resumable artifact, so log only an
              // 8-char preview (same policy as the node_session_resumed event above).
              getLog().warn(
                {
                  nodeId: node.id,
                  provider,
                  workflowRunId: ctx.workflowRun.id,
                  resumeSessionId: `${resumeSessionId.slice(0, 8)}…`,
                  priorArtifactsFound: recoveryPointer !== '',
                },
                'dag.session_resume_failed'
              );
              await safeSendMessage(
                ctx.platform,
                ctx.conversationId,
                `⚠️ Node \`${node.id}\`: could not resume the prior session — continued with a fresh session, so the earlier context was not restored.${recoveryPointer}`,
                { workflowId: ctx.workflowRun.id, nodeName: node.id }
              );
            }

            // Persist (or drop) the node's provider session ID for the next run in this scope.

View on GitHub (pinned to 0773b97458)

Solutions

Check server logs for the underlying resume error and the truncated session id
Confirm the provider account/API is healthy and the session still exists
Accept the fresh session, or clear persisted sessions and re-run
If the recovery pointer lists prior artifacts, feed those back into the new session

Defensive patterns

Strategy: fallback

Try / catch

try {
  await runNode(node);
} catch (err) {
  if (isSessionResumeFailed(err)) {
    console.warn(`session resume failed for ${node.id}; node continued fresh — re-feed prior artifacts if context matters`);
  } else throw err;
}

Prevention

Re-run promptly after provider outages so sessions are still resumable
Monitor provider session expiry windows
Keep provider credentials valid to avoid resume-auth failures

When it happens

Trigger: The DAG executor found a persisted resumeSessionId for the node but the provider call to resume it threw; the catch branch logs `dag.session_resume_failed` and continues fresh.

Common situations: Provider session expired or was deleted server-side; provider API outage; session id from an older provider version no longer resumable.

Related errors

AI-assisted analysis of coleam00/Archon@0773b97458 (2026-09-01). Data as JSON: /api/errors/a6142560662c1518. Report an issue: GitHub.