Greptile Summary

This PR adds a fallback mechanism in QmdMemoryManager.readFile() so that when a filesystem path is missing (due to qmd's slugification of filenames like My Recipe Notes.md → my-recipe-notes.md), it retries document retrieval via qmd get using a qmd:// URI. The new private getQmdDoc helper correctly decomposes the relPath into collection and sub-path components, mirroring the logic already in resolveReadPath, and wraps the CLI call in a try/catch so failures degrade gracefully to the existing empty-string response.

Key observations:

• Logic bug: The early return inside the fallback block (line 900) ignores params.from and params.lines. The file-exists path at lines 905–923 slices the content via readPartialText or manual line arithmetic, but the new branch skips this entirely. Any memory_get call that specifies a line window on a slugified qmd path will receive the full document instead of the requested slice.
• The path-traversal protections provided by resolveReadPath (collection allow-list, isWithinRoot check) are still exercised before the fallback is reached, so the URI passed to qmd get is already bounded.
• No automated tests are added for the new fallback behavior.

Confidence Score: 3/5

• The core fix works for the full-document case but contains a pagination bug that causes incorrect output when from/lines are supplied.
• The primary use case (returning full document content for qmd search results) is correct. However, the early-return in the fallback path bypasses the existing from/lines pagination logic, which is a clear logical regression that will silently return wrong data when callers specify a line window.
• src/memory/qmd-manager.ts — specifically the new early-return block inside readFile and the getQmdDoc helper.

This is a comment left during a code review.
Path: src/memory/qmd-manager.ts
Line: 896-902

Comment:
**Pagination ignored on `getQmdDoc` fallback**

When `getQmdDoc` successfully retrieves content and `params.from` / `params.lines` are specified, the full document is returned without slicing. The normal (file-exists) code path at lines 905–923 carefully applies pagination via `readPartialText` or manual slicing, but this new early-return branch bypasses all of that logic.

The `memory_get` tool in `src/agents/tools/memory-tool.ts` passes `from` and `lines` directly to `readFile`, so a caller that requests a specific window (e.g. `from: 10, lines: 5`) on a slugified qmd path would silently receive the entire document instead of the expected slice.

```suggestion
      // Fall back to `qmd get` which can resolve slugified paths.
      if (relPath.startsWith("qmd/")) {
        const qmdText = await this.getQmdDoc(relPath);
        if (qmdText !== null) {
          if (params.from !== undefined || params.lines !== undefined) {
            const allLines = qmdText.split("\n");
            const start = Math.max(1, params.from ?? 1);
            const count = Math.max(1, params.lines ?? allLines.length);
            return { text: allLines.slice(start - 1, start - 1 + count).join("\n"), path: relPath };
          }
          return { text: qmdText, path: relPath };
        }
      }
```

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

_{Last reviewed commit: 4ebcb5a}