Greptile Summary

This PR suppresses raw dreaming metadata dumps from being written to daily memory/YYYY-MM-DD.md files when the narrative generation falls back to the request-scoped path. The core approach is sound — narrative generation is moved before the inline write so the fallback flag is available, and an empty inlineBodyLines triggers a new removeManagedMarkdownBlock helper instead of replaceManagedMarkdownBlock.

• P1: The refactor dropped the withTrailingNewline wrapper from the normal (non-suppressed) write path in writeDailyDreamingPhaseBlock. The old code always called withTrailingNewline(updated); the new branch only applies it inside removeManagedMarkdownBlock. Every successful dreaming write will now omit the trailing newline from the daily file.

Confidence Score: 3/5

Not safe to merge as-is — the refactor introduces a regression on the normal write path that affects every successful dreaming write, not just fallback cases.

One P1 finding: withTrailingNewline is silently dropped from the replaceManagedMarkdownBlock branch during the inline write refactor. This will cause every non-fallback dreaming write to omit the trailing newline from daily memory files going forward. The fix is small and contained to dreaming-markdown.ts.

extensions/memory-core/src/dreaming-markdown.ts — lines 105–122, the writeDailyDreamingPhaseBlock inline write branch.

This is a comment left during a code review.
Path: extensions/memory-core/src/dreaming-markdown.ts
Line: 105-122

Comment:
**Missing `withTrailingNewline` on the normal write path**

The old code always called `withTrailingNewline(updated)` before writing, regardless of which branch produced `updated`. The new code applies `withTrailingNewline` inside `removeManagedMarkdownBlock` (the suppression branch), but the `replaceManagedMarkdownBlock` branch no longer has it. Every successful non-fallback inline dreaming write will now drop the trailing newline from the daily memory file.

```suggestion
    const updated =
      inlineBody.length > 0
        ? replaceManagedMarkdownBlock({
            original,
            heading: DAILY_PHASE_HEADINGS[params.phase],
            startMarker: markers.start,
            endMarker: markers.end,
            body: inlineBody,
          })
        : removeManagedMarkdownBlock({
            original,
            heading: DAILY_PHASE_HEADINGS[params.phase],
            startMarker: markers.start,
            endMarker: markers.end,
          });
    const finalContent = inlineBody.length > 0 ? withTrailingNewline(updated) : updated;
    if (finalContent !== original) {
      await fs.writeFile(inlinePath, finalContent, "utf-8");
    }
```

How can I resolve this? If you propose a fix, please make it concise.

---

This is a comment left during a code review.
Path: extensions/memory-core/src/dreaming-narrative.ts
Line: 916-921

Comment:
**Outer catch shadows request-scoped fallback on append failure**

If the `appendNarrativeEntry` call inside `startNarrativeRunOrFallback`'s catch block throws (e.g. a transient write error), that exception propagates through the outer `try` and is caught here, returning `{ fallbackUsed: false }`. The subagent runtime WAS request-scoped, so the daily memory file will still contain the raw dump — but suppression never fires. The window is small, but it is the exact scenario this PR aims to guard against.

How can I resolve this? If you propose a fix, please make it concise.

_{Reviews (1): Last reviewed commit: "fix(memory-core): suppress raw dreaming ..." | Re-trigger Greptile}

Related work from PRtags group safe-marten-ot47

Title: Open PR candidate: Dream Diary duplicate/raw fallback cleanup

* This PR

Tightened the dreaming follow-up: inline daily-memory writes keep their trailing newline again, and request-scoped narrative fallback now reports whether the diary append actually succeeded before suppressing inline output. Added regression coverage for the fallback-write-failed path too. Local targeted testing is blocked in this environment by the repo non-isolated Vitest runner issue, so I am leaning on CI for the final pass.

Picked up the daily-note formatting follow-up. Removing a managed dreaming block now only removes the targeted block instead of collapsing unrelated blank lines or trimming the rest of the note, and I added a regression test for that cleanup path. Local Vitest is still blocked in this environment by the repo's current non-isolated-runner issue on Node 22.12.0, so CI is doing the real verification.

Picked up the last daily-note cleanup edge case. Removing the managed dreaming block now trims only the seam it creates, so the surrounding note spacing stays intact without ballooning the gap. Local Vitest is still blocked here by the current non-isolated runner issue, but I verified the exact removal case and the normal trailing-newline path with a direct targeted runtime check.

Pushed an empty chore: retrigger ci commit because the remaining red check is the shared Telegram extension shard hitting ERR_WORKER_OUT_OF_MEMORY after its tests pass, and this token cannot rerun the failed workflow directly.

Pushed 8b3cfd6505 to close the remaining dreaming fallback edge case. Request-scoped narrative fallback now reports fallbackUsed: true even if writing the fallback narrative fails, so the raw inline dreaming dump is still suppressed. Focused memory-core dreaming tests pass locally.

Rebased on current main to pick up the talk silence-timeout docs baseline that was failing the runtime-config shard. I verified the expected 700 ms/900 ms docs and help text are present on this head; GitHub checks are rerunning now.

Synced the MiniMax FAQ troubleshooting model refs that were failing the agentic-agents docs-sync shard. Verified the expected MiniMax M2.7 refs are present in docs/help/faq.md and git diff --check is clean; GitHub checks are rerunning.

Added the stale internal docs link fixes that were failing check-docs after the previous push. Verified docs-link-audit now reports broken_links=0; GitHub checks are rerunning.

Rebased this branch onto current main and tightened the dreaming fallback flow: phase output is persisted before narrative generation, request-scoped fallback only reports fallbackUsed after the fallback entry is written, and fallback suppression still removes raw inline dumps after a successful fallback. Local check: pnpm test -- extensions/memory-core/src/dreaming-markdown.test.ts extensions/memory-core/src/dreaming-narrative.test.ts extensions/memory-core/src/dreaming-phases.test.ts passes.

Swept this PR again. Existing CI is green, and the inline Greptile/Codex comments are addressed on the current head: newline preservation, targeted managed-block removal, fallback success reporting, and phase-write ordering are covered. Focused tests passed locally: pnpm test -- extensions/memory-core/src/dreaming-markdown.test.ts extensions/memory-core/src/dreaming-narrative.test.ts extensions/memory-core/src/dreaming-phases.test.ts. Added 🚀 reactions to the addressed comments.

Thanks for the context here. I swept through the related work, and this is now duplicate or superseded.

Keep this PR open but not merge-ready: current main solved the default daily-memory pollution by shipping separate storage by default, yet explicit inline mode remains an opt-in path and this branch carries unique inline cleanup. The patch still misses the detached cron/system-event path and can double-record dream completion state when it removes the inline block, and it still needs real behavior proof plus a rebase.

Canonical path: Close this stale PR. The latest review rated it F, the branch still lacks merge-ready proof, and there has been no human follow-up after the durable review.

So I’m closing this here because the remaining work is already tracked in the canonical issue.

Rebased this branch onto current upstream/main and resolved the memory-core narrative conflict. The request-scoped fallback success path keeps its info-level log, and the focused memory-core tests pass locally: pnpm test -- extensions/memory-core/src/dreaming-markdown.test.ts extensions/memory-core/src/dreaming-narrative.test.ts extensions/memory-core/src/dreaming-phases.test.ts.

ClawSweeper PR egg

🎁 Pass real behavior proof to wake the egg and unlock a hatchable treat.

This pull request has been automatically marked as stale due to inactivity.
Please add updates or it will be closed.

ClawSweeper applied the proposed close for this PR.

• Action: closed this PR.
• Close reason: duplicate or superseded.
• Evidence: durable ClawSweeper review.