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.

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.

Appendix: 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)