Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

qa/scenarios/memory/memory-dreaming-sweep.yaml

@@ -0,0 +1,288 @@
+title: Memory dreaming sweep
+
+scenario:
+  id: memory-dreaming-sweep
+  surface: memory
+  coverage:
+    primary:
+      - memory.dreaming
+  objective: Verify enabling dreaming creates the managed sweep, stages light and REM artifacts, and consolidates repeated recall signals into durable memory.
+  successCriteria:
+    - Dreaming can be enabled and doctor.memory.status reports the managed sweep cron.
+    - Repeated recall signals give the dreaming sweep real material to process.
+    - A dreaming sweep writes Light Sleep and REM Sleep blocks, then promotes the canary into MEMORY.md.
+  docsRefs:
+    - docs/concepts/dreaming.md
+    - docs/reference/memory-config.md
+    - docs/web/control-ui.md
+  codeRefs:
+    - extensions/memory-core/src/dreaming.ts
+    - extensions/memory-core/src/dreaming-phases.ts
+    - src/gateway/server-methods/doctor.ts
+    - extensions/qa-lab/src/suite.ts
+  execution:
+    kind: flow
+    summary: Verify enabling dreaming creates the managed sweep, stages light and REM artifacts, and consolidates repeated recall signals into durable memory.
+    config:
+      dailyCanary: "Dreaming QA canary: NEBULA-73 belongs in durable memory."
+      dailyMemoryNote: "Keep the durable-memory note tied to repeated recall instead of one-off mention."
+      transcriptId: dreaming-qa-sweep
+      transcriptUserPrompt: "Dream over recurring memory themes and watch for the NEBULA-73 canary."
+      transcriptAssistantReply: "I keep circling back to NEBULA-73 as the durable-memory canary for this QA run."
+      searchQueries:
+        - "dreaming qa canary nebula-73"
+        - "durable memory canary nebula 73"
+        - "which canary belongs to the dreaming qa check"
+      expectedNeedle: "NEBULA-73"
+
+flow:
+  steps:
+    - name: enables dreaming and registers the managed sweep cron
+      actions:
+        - call: readConfigSnapshot
+          saveAs: original
+          args:
+            - ref: env
+        - set: pluginEntries
+          value:
+            expr: "original.config.plugins && typeof original.config.plugins === 'object' ? original.config.plugins.entries : undefined"
+        - set: memoryCoreEntry
+          value:
+            expr: "pluginEntries && typeof pluginEntries['memory-core'] === 'object' ? pluginEntries['memory-core'] : undefined"
+        - set: memoryCoreConfig
+          value:
+            expr: "memoryCoreEntry && typeof memoryCoreEntry.config === 'object' ? memoryCoreEntry.config : undefined"
+        - set: originalDreaming
+          value:
+            expr: "memoryCoreConfig?.dreaming"
+        - call: patchConfig
+          args:
+            - env:
+                ref: env
+              patch:
+                plugins:
+                  entries:
+                    memory-core:
+                      config:
+                        dreaming:
+                          enabled: true
+                          phases:
+                            deep:
+                              minScore: 0
+                              minRecallCount: 3
+                              minUniqueQueries: 3
+        - call: waitForGatewayHealthy
+          args:
+            - ref: env
+        - call: waitForQaChannelReady
+          args:
+            - ref: env
+            - 60000
+        - try:
+            actions:
+              - call: waitForCondition
+                saveAs: status
+                args:
+                  - lambda:
+                      async: true
+                      expr: "(() => readDoctorMemoryStatus(env).then((payload) => payload.dreaming?.phases?.deep?.managedCronPresent === true ? payload : undefined))()"
+                  - expr: liveTurnTimeoutMs(env, 90000)
+                  - 500
+              - call: listCronJobs
+                saveAs: jobs
+                args:
+                  - ref: env
+              - set: managed
+                value:
+                  expr: "findManagedDreamingCronJob(jobs)"
+              - assert:
+                  expr: "Boolean(managed?.id)"
+                  message: managed dreaming cron job missing after enablement
+              - set: dreamingOriginal
+                value:
+                  expr: "structuredClone(originalDreaming)"
+              - set: dreamingCronId
+                value:
+                  expr: "managed.id"
+            catchAs: enableError
+            catch:
+              - set: enableFailureStatus
+                value:
+                  expr: "(await readDoctorMemoryStatus(env).catch((error) => ({ error: String(error?.message ?? error) })))"
+              - set: enableFailureJobs
+                value:
+                  expr: "(await listCronJobs(env).catch((error) => [{ error: String(error?.message ?? error) }]))"
+              - call: patchConfig
+                args:
+                  - env:
+                      ref: env
+                    patch:
+                      plugins:
+                        entries:
+                          memory-core:
+                            config:
+                              dreaming:
+                                expr: "originalDreaming === undefined ? null : structuredClone(originalDreaming)"
+              - call: waitForGatewayHealthy
+                args:
+                  - ref: env
+              - call: waitForQaChannelReady
+                args:
+                  - ref: env
+                  - 60000
+              - throw:
+                  expr: "`managed dreaming cron missing: ${enableError?.message ?? enableError}; status=${JSON.stringify(enableFailureStatus)} jobs=${JSON.stringify(enableFailureJobs)}`"
+      detailsExpr: "JSON.stringify({ enabled: status.dreaming?.enabled ?? false, managedCronPresent: status.dreaming?.phases?.deep?.managedCronPresent ?? false, nextRunAtMs: status.dreaming?.phases?.deep?.nextRunAtMs ?? null })"
+
+    - name: runs the sweep after repeated recall signals and writes promotion artifacts
+      actions:
+        - assert:
+            expr: "Boolean(dreamingCronId)"
+            message: missing managed dreaming cron id
+        - set: cronId
+          value:
+            ref: dreamingCronId
+        - set: dreamingDay
+          value:
+            expr: "formatMemoryDreamingDay(Date.now())"
+        - set: dailyPath
+          value:
+            expr: "path.join(env.gateway.workspaceDir, 'memory', `${dreamingDay}.md`)"
+        - set: lightReportPath
+          value:
+            expr: "path.join(env.gateway.workspaceDir, 'memory', 'dreaming', 'light', `${dreamingDay}.md`)"
+        - set: remReportPath
+          value:
+            expr: "path.join(env.gateway.workspaceDir, 'memory', 'dreaming', 'rem', `${dreamingDay}.md`)"
+        - set: memoryPath
+          value:
+            expr: "path.join(env.gateway.workspaceDir, 'MEMORY.md')"
+        - set: homeDir
+          value:
+            expr: "env.gateway.runtimeEnv.HOME ?? env.gateway.runtimeEnv.OPENCLAW_HOME ?? env.gateway.tempRoot"
+        - set: sessionsDir
+          value:
+            expr: "resolveSessionTranscriptsDirForAgent('qa', env.gateway.runtimeEnv, () => homeDir)"
+        - set: transcriptPath
+          value:
+            expr: "path.join(sessionsDir, `${config.transcriptId}.jsonl`)"
+        - try:
+            actions:
+              - call: fs.mkdir
+                args:
+                  - expr: "path.dirname(dailyPath)"
+                  - recursive: true
+              - call: fs.mkdir
+                args:
+                  - ref: sessionsDir
+                  - recursive: true
+              - call: fs.writeFile
+                args:
+                  - ref: dailyPath
+                  - expr: "[`# ${dreamingDay}`, '', `- ${config.dailyCanary}`, `- ${config.dailyMemoryNote}`].join('\\n') + '\\n'"
+                  - utf8
+              - set: now
+                value:
+                  expr: "Date.now()"
+              - call: fs.writeFile
+                args:
+                  - ref: transcriptPath
+                  - expr: "[JSON.stringify({ type: 'session', id: config.transcriptId, timestamp: new Date(now - 120000).toISOString() }), JSON.stringify({ type: 'message', message: { role: 'user', timestamp: new Date(now - 90000).toISOString(), content: [{ type: 'text', text: config.transcriptUserPrompt }] } }), JSON.stringify({ type: 'message', message: { role: 'assistant', timestamp: new Date(now - 60000).toISOString(), content: [{ type: 'text', text: config.transcriptAssistantReply }] } })].join('\\n') + '\\n'"
+                  - utf8
+              - call: fs.rm
+                args:
+                  - ref: memoryPath
+                  - force: true
+              - call: forceMemoryIndex
+                args:
+                  - env:
+                      ref: env
+                    query:
+                      expr: "config.searchQueries[0]"
+                    expectedNeedle:
+                      expr: config.expectedNeedle
+              - call: sleep
+                args:
+                  - 1000
+              - forEach:
+                  items:
+                    expr: config.searchQueries
+                  item: query
+                  actions:
+                    - call: runQaCli
+                      saveAs: payload
+                      args:
+                        - ref: env
+                        - - memory
+                          - search
+                          - --agent
+                          - qa
+                          - --json
+                          - --query
+                          - ref: query
+                        - timeoutMs:
+                            expr: liveTurnTimeoutMs(env, 60000)
+                          json: true
+                    - assert:
+                        expr: "JSON.stringify(payload.results ?? []).includes(config.expectedNeedle)"
+                        message:
+                          expr: "`memory search missed dreaming canary for query: ${query}`"
+              - set: cronRunStartedAt
+                value:
+                  expr: "Date.now()"
+              - call: env.gateway.call
+                saveAs: cronRun
+                args:
+                  - cron.run
+                  - id:
+                      ref: cronId
+                    mode: force
+                  - timeoutMs:
+                      expr: liveTurnTimeoutMs(env, 30000)
+              - assert:
+                  expr: "cronRun.enqueued === true && Boolean(cronRun.runId)"
+                  message:
+                    expr: "`dreaming cron did not enqueue a background run: ${JSON.stringify(cronRun)}`"
+              - call: waitForCronRunCompletion
+                saveAs: finishedRun
+                args:
+                  - callGateway:
+                      expr: "(method, rpcParams, opts) => env.gateway.call(method, rpcParams, opts)"
+                    jobId:
+                      ref: cronId
+                    afterTs:
+                      ref: cronRunStartedAt
+                    timeoutMs:
+                      expr: liveTurnTimeoutMs(env, 180000)
+              - assert:
+                  expr: "finishedRun.status === 'ok'"
+                  message:
+                    expr: "`dreaming cron finished with ${finishedRun.status ?? 'unknown'}: ${JSON.stringify(finishedRun)}`"
+              - call: waitForCondition
+                saveAs: promoted
+                args:
+                  - lambda:
+                      async: true
+                      expr: "(async () => { const status = await readDoctorMemoryStatus(env); const lightReport = await fs.readFile(lightReportPath, 'utf8').catch(() => ''); const remReport = await fs.readFile(remReportPath, 'utf8').catch(() => ''); const promotedMemory = await fs.readFile(memoryPath, 'utf8').catch(() => ''); if (!lightReport.includes('# Light Sleep')) return undefined; if (!remReport.includes('# REM Sleep')) return undefined; if (!promotedMemory.includes(config.expectedNeedle)) return undefined; if (status.dreaming?.phases?.deep?.managedCronPresent !== true) return undefined; if ((status.dreaming?.promotedTotal ?? 0) < 1) return undefined; return { status, lightReport, remReport, promotedMemory }; })()"
+                  - expr: liveTurnTimeoutMs(env, 180000)
+                  - 1000
+            finally:
+              - call: patchConfig
+                args:
+                  - env:
+                      ref: env
+                    patch:
+                      plugins:
+                        entries:
+                          memory-core:
+                            config:
+                              dreaming:
+                                expr: "dreamingOriginal === undefined ? null : structuredClone(dreamingOriginal)"
+              - call: waitForGatewayHealthy
+                args:
+                  - ref: env
+              - call: waitForQaChannelReady
+                args:
+                  - ref: env
+                  - 60000
+      detailsExpr: "JSON.stringify({ promotedTotal: promoted.status.dreaming?.promotedTotal ?? 0, shortTermCount: promoted.status.dreaming?.shortTermCount ?? 0, phaseSignalCount: promoted.status.dreaming?.phaseSignalCount ?? 0, lightSleep: promoted.lightReport.includes('# Light Sleep'), remSleep: promoted.remReport.includes('# REM Sleep') })"