MetaList 0.18.0__tar.gz → 0.19.0__tar.gz

{metalist-0.18.0/metalist.egg-info → metalist-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metalist
-Version: 0.18.0
+Version: 0.19.0
 Summary: A minimalist single-user note-taking app with SSR, fast in-memory tree operations, and efficient sync.
 Project-URL: Homepage, https://github.com/evolvingstuff/metalist
 Project-URL: Repository, https://github.com/evolvingstuff/metalist
@@ -51,6 +51,15 @@ A minimalist single-user note-taking app focused on server-side rendering (SSR),
 - Multi-tab search contexts with server-persisted scroll/search state (survives browser restarts)
 - Manual namespace backups/restores to a user-selected backup folder with retention controls
 
+## Changes in 0.19.0
+
+- Paste formats: pasting a fenced code block that names its language tags the note `@markdown`, and `@markdown` now colours that code like `@code=<language>` (with its label). Code copied from VS Code is tagged `@code=<its language>`, and cells copied from Excel, Google Sheets or Numbers become CSV text tagged `@csv`.
+- Text that only looks like a format is offered, not applied: after pasting CSV-like, Markdown-like or code-like text, a small card says "Apply as CSV" / "Apply as Markdown" / "Apply as Python" (up to three close languages for code) with "Skip". The card moves nothing and never takes the keyboard; typing on, Escape or a click elsewhere closes it. It also appears when the paste makes a new note.
+- Right-click a tag already in the tag bar or the search box for **About this tag**: whether the note names it, the notes it shares with your other tags, whether a parent or a rule already gives it, its synonyms and implications, how many notes have it ("Only on this note" hints at a typo); in the search box, what it finds and what leaving it out removes. Edit Tag Relationships now comes first in the tag menu, at a fixed place under the pointer.
+- Tag suggestions: a web address in a note counts only by its site's name, so a YouTube link no longer suggests `HTTPS` or `V-neuron`; one letter alone no longer names a tag with longer words. A suggestion without evidence now says only what is true (what you typed matches, which part of its name the note has) instead of "Nothing in this note points to it".
+- Fixed: accepting a Grammarly suggestion while editing could undo itself and end editing, when Grammarly drew its card in an element MetaList did not recognise.
+- Removed the "Make pseudo-suggestions" test item from the note menu.
+
 ## Changes in 0.18.0
 
 - Right-click a tag suggestion, in the tag bar or the search bar, to see why it is suggested. The menu starts with **Why suggested**: the words of the note that name the tag (or a synonym), the tags it goes with and on how many notes, notes sharing this note's tags, whether it already applies through a parent or a rule, or that nothing in the note points to it; then how often the tag is used. Search suggestions also say how often you worked with a tag lately (when that put it first), what your search so far finds, or what leaving it out removes. The reasons are MetaList's own ranking, not the AI's, and appear instantly.

{metalist-0.18.0 → metalist-0.19.0}/README.md

@@ -12,6 +12,15 @@ A minimalist single-user note-taking app focused on server-side rendering (SSR),
 - Multi-tab search contexts with server-persisted scroll/search state (survives browser restarts)
 - Manual namespace backups/restores to a user-selected backup folder with retention controls
 
+## Changes in 0.19.0
+
+- Paste formats: pasting a fenced code block that names its language tags the note `@markdown`, and `@markdown` now colours that code like `@code=<language>` (with its label). Code copied from VS Code is tagged `@code=<its language>`, and cells copied from Excel, Google Sheets or Numbers become CSV text tagged `@csv`.
+- Text that only looks like a format is offered, not applied: after pasting CSV-like, Markdown-like or code-like text, a small card says "Apply as CSV" / "Apply as Markdown" / "Apply as Python" (up to three close languages for code) with "Skip". The card moves nothing and never takes the keyboard; typing on, Escape or a click elsewhere closes it. It also appears when the paste makes a new note.
+- Right-click a tag already in the tag bar or the search box for **About this tag**: whether the note names it, the notes it shares with your other tags, whether a parent or a rule already gives it, its synonyms and implications, how many notes have it ("Only on this note" hints at a typo); in the search box, what it finds and what leaving it out removes. Edit Tag Relationships now comes first in the tag menu, at a fixed place under the pointer.
+- Tag suggestions: a web address in a note counts only by its site's name, so a YouTube link no longer suggests `HTTPS` or `V-neuron`; one letter alone no longer names a tag with longer words. A suggestion without evidence now says only what is true (what you typed matches, which part of its name the note has) instead of "Nothing in this note points to it".
+- Fixed: accepting a Grammarly suggestion while editing could undo itself and end editing, when Grammarly drew its card in an element MetaList did not recognise.
+- Removed the "Make pseudo-suggestions" test item from the note menu.
+
 ## Changes in 0.18.0
 
 - Right-click a tag suggestion, in the tag bar or the search bar, to see why it is suggested. The menu starts with **Why suggested**: the words of the note that name the tag (or a synonym), the tags it goes with and on how many notes, notes sharing this note's tags, whether it already applies through a parent or a rule, or that nothing in the note points to it; then how often the tag is used. Search suggestions also say how often you worked with a tag lately (when that put it first), what your search so far finds, or what leaving it out removes. The reasons are MetaList's own ranking, not the AI's, and appear instantly.

{metalist-0.18.0 → metalist-0.19.0}/app/api/note_requests.py

@@ -127,6 +127,22 @@ class TagSuggestionsRequest(TypedDict):
     prefix: Text
     content_html: Content
 
+@with_config(ConfigDict(strict=True))
+class TagDetailsRequest(TypedDict):
+    note_id: Identifier
+    tag: Identifier
+    tags_text: Text
+    content_html: Content
+
+@with_config(ConfigDict(strict=True))
+class SearchTagDetailsRequest(TypedDict):
+    query: Text
+    tag: Identifier
+    start: Nonnegative
+    end: Nonnegative
+    excluded: bool
+    windowDays: WindowDays
+
 @with_config(ConfigDict(strict=True))
 class CreateNoteTopRequest(TypedDict):
     first_visible_note_id: Text | None
@@ -180,12 +196,6 @@ class AddSelectedTextTagRequest(TypedDict):
     undoContext: UndoContext
     viewport: Viewport
 
-@with_config(ConfigDict(strict=True))
-class MakePseudoTagProposalsRequest(TypedDict):
-    clientId: Identifier
-    undoContext: UndoContext
-    viewport: Viewport
-
 @with_config(ConfigDict(strict=True))
 class AcceptTagProposalRequest(TypedDict):
     proposal: Identifier

{metalist-0.18.0 → metalist-0.19.0}/app/api/routes/notes.py

@@ -20,6 +20,8 @@ from app.api.note_requests import (
     SearchSuggestionInteractionRequest,
     TabSearchInteractionRequest,
     TagSuggestionsRequest,
+    TagDetailsRequest,
+    SearchTagDetailsRequest,
     DictationPasteRequest,
     CreateNoteTopRequest,
     CreateSiblingRequest,
@@ -28,7 +30,6 @@ from app.api.note_requests import (
     UpdateNoteRequest,
     SaveNoteRequest,
     AddSelectedTextTagRequest,
-    MakePseudoTagProposalsRequest,
     AcceptTagProposalRequest,
     RejectTagProposalRequest,
     SplitNoteRequest,
@@ -77,7 +78,6 @@ from app.services.link_title_retry import (
 from app.usecases.add_selected_text_tag import CmdAddSelectedTextTag
 from app.usecases.tag_proposals import (
     CmdAcceptTagProposal,
-    CmdMakePseudoTagProposals,
     CmdRejectTagProposal,
 )
 from app.usecases.delete_subtree import CmdDeleteSubtree
@@ -138,6 +138,8 @@ from app.services.note_fullscreen import build_note_fullscreen_markup
 from app.services.link_titles import link_title_store
 from app.services.search_index import search_index
 from app.services.dictation_cleanup import clean_dictated_paste
+from app.services.tag_details import describe_search_tag
+from app.services.tag_details import describe_tag_bar_tag
 from app.services.tag_suggestion_reasons import search_suggestion_reasons
 from app.services.tag_suggestions import suggest_tags_with_reasons_for_note
 from app.services.client_state_service import suggests_already_applying_tags
@@ -654,6 +656,32 @@ def tag_suggestions(request: Request, payload: TagSuggestionsRequest) -> Dict[st
     }
 
 
+@router.post("/notes/tag-details")
+@transactional_route
+def tag_details(payload: TagDetailsRequest) -> Dict[str, object]:
+    """About a tag in a note's tag bar, shown when it is right-clicked (docs/ui/tag-bar.md)."""
+    note_id = payload["note_id"]
+    _require_note_present(note_id, context="notes.tag-details")
+    lines = describe_tag_bar_tag(
+        note_id=note_id, tag=payload["tag"], tags_text=payload["tags_text"], content_html=payload["content_html"],
+    )
+    return {"lines": list(lines)}
+
+
+@router.post("/notes/search-tag-details")
+@transactional_route
+def search_tag_details(request: Request, payload: SearchTagDetailsRequest) -> Dict[str, object]:
+    """About a tag in the search box, shown when it is right-clicked (docs/ui/controls.md)."""
+    window_days = tuple(payload["windowDays"])
+    validate_tag_activity_windows(window_days)
+    lines = describe_search_tag(
+        query=payload["query"], tag=payload["tag"], start=payload["start"], end=payload["end"],
+        is_excluded=payload["excluded"], window_days=window_days,
+        token=_require_bearer_token(request), today=current_local_date(),
+    )
+    return {"lines": list(lines)}
+
+
 @router.get("/notes/export-html")
 def export_notes_html(request: Request) -> Response:
     token = _require_bearer_token(request)
@@ -914,21 +942,6 @@ def add_selected_text_tag(request: Request, note_id: str, body: AddSelectedTextT
     return response
 
 
-@router.post("/notes/{note_id}/tag-proposals/pseudo")
-@transactional_route
-def make_pseudo_tag_proposals(request: Request, note_id: str, body: MakePseudoTagProposalsRequest):
-    token = _require_bearer_token(request)
-    viewport = _require_viewport(body)
-    _require_note_present(note_id, context="notes.tag-proposals.pseudo")
-    return CmdMakePseudoTagProposals(
-        note_id=note_id,
-        token=token,
-        client_id=body["clientId"],
-        undo_context=body["undoContext"],
-        viewport=viewport,
-    ).execute()
-
-
 def _execute_tag_proposal_mutation(*, command: QueryCommand) -> Dict[str, object]:
     return command.execute()
 

{metalist-0.18.0 → metalist-0.19.0}/app/services/agent/skills/help-formatting.md

@@ -145,6 +145,7 @@ Other (non-meta) tags may also appear inside wrapper tokens (e.g. `{{foo bar}}`)
 ## Markdown meta tags
 - `@markdown`: renders the note content as Markdown in view mode on the server.
 - Scoped Markdown renders only the matching wrapped region.
+- Fenced code that names a language (```` ```python ````, ```` ```js ````, any language name or alias `@code=` accepts, in any case) is coloured as `@code=<language>` colours it, with the language label above the block. A fence with no language, or one naming plain text (`text`, `output`, `console`) or a language MetaList does not know, stays plain, with no badge. Fenced `mermaid` blocks are unaffected.
 - Fenced `mermaid` blocks render as responsive SVG diagrams in the app. They use a compact layout (13 px labels and tight spacing between nodes and rows); diagrams are never capped or scaled to fit, so large ones keep all their detail. The pinned Mermaid runtime loads locally and only when a visible note contains a Mermaid fence; no diagram source is sent to a CDN or external service.
 - In a help answer, show the literal Mermaid source the user must type: open an outer `text` block with four backticks, put the triple-backtick `mermaid` block inside it, close that inner block with three backticks, and close the outer block with four backticks before returning to prose. Never use only three backticks for the outer block. A direct `mermaid` fence renders as a diagram in AI chat instead of displaying its source.
 - Do not promise support for named Mermaid diagram families that this reference does not document. Use a basic flowchart for the example and describe Mermaid support generically.
@@ -209,9 +210,23 @@ Other (non-meta) tags may also appear inside wrapper tokens (e.g. `{{foo bar}}`)
   - JSON (a complete object or array) → `@json`
   - a chess FEN position → `@chess`
   - a unified diff (with `@@` section lines, `---`/`+++` headers, or `diff --git`) → `@diff`
-  - Mermaid starting with a diagram keyword (`graph TD`, `sequenceDiagram`, `gantt`...) → `@mermaid`; a fenced ```` ```mermaid ```` block → `@markdown`
+  - Mermaid starting with a diagram keyword (`graph TD`, `sequenceDiagram`, `gantt`...) → `@mermaid`
+  - a fenced code block naming its language (```` ```python ````, ```` ```mermaid ````), alone or with text around it → `@markdown` (the fence says it is Markdown; a bare ```` ``` ```` or an unclosed fence is not enough)
   - a pure LaTeX block (`$$...$$`, `\[...\]`, or `\begin{...}...\end{...}`) → `@LaTeX`
+  - code copied from VS Code (two lines or more) → `@code=<its language>`, from the language VS Code puts on the clipboard (`vscode-editor-data`): `@code=python`, `@code=bash` for shell scripts, `@markdown` for Markdown files; JSON that parses stays `@json`; plain text and unlisted languages get nothing
+  - cells copied from a spreadsheet (Excel, Google Sheets, Numbers: an HTML table on the clipboard) → the cells as CSV text (commas, quoting cells that hold commas, quotes or line breaks) and `@csv`
 - Into an otherwise empty note (or with all of its text selected), and when pasting creates a new note, the plain tag is added. Into a note with content, the pasted text is wrapped `((...))` and `((@json))` (etc.) is added, so the existing text is untouched.
-- Nothing is added for anything uncertain (prose, code, CSV, JSON-looking text that does not parse), when the note already has a renderer tag, when pasting inside an existing wrapped region, or when `((...))` is already in use in that note.
+- Nothing is added at once for anything uncertain (prose, JSON-looking text that does not parse); CSV-like, Markdown-like and code-like text is offered instead (see below). Nothing is added or offered when the note already has a renderer tag, when pasting inside an existing wrapped region, or when `((...))` is already in use in that note.
 - `⌘Z` right after the paste removes the added tag together with the pasted text (one undo step, like a normal paste). `⇧⌘V` (Ctrl+Shift+V) pastes as plain text without detection.
 - Implementation: `paste-format-detection-service.js` (detection and planning, tests in `tests/unit/paste_format_detection.test.mjs`), wired in `keyboard-events.js`.
+
+## Paste format guesses
+- Text that only looks like a format is pasted as plain text, and a small card just below where the paste ended offers it: `Apply as Markdown` (or `Apply as CSV`, `Apply as Python`) and `Skip`. When several languages are close, it reads `Looks like code:` with up to three, best first (`Ruby`, `Python`), then `Skip`. A wrong guess costs nothing.
+- What is offered:
+  - CSV-like: three or more lines with the same number of comma-separated cells (two or more; commas inside quotes do not count), short cells, no sentences → `@csv`.
+  - Markdown-like: two or more different kinds of signs (`#` headings, a list of two or more items, `**bold**`, `` `code` ``, `[text](url)` links, `>` quotes, a bare ```` ``` ```` fence), or a table (`| a | b |` with its `---` line) → `@markdown`. A lone bullet list is an ordinary note and is not offered.
+  - Code: mostly code-like lines (ending in `;`, `{`, `)`, `:`..., indented code, assignments and calls, no sentences), or a strong sign of one language → `@code=<language>`, for SQL, Python, Ruby, JavaScript, TypeScript, Shell (`@code=bash`), HTML, XML, CSS, Java, C, C++, C#, Go, Rust, YAML and Dockerfile, each scored on its own signs (`SELECT ... FROM`, `def f():`, `do |x|`, `console.log`, `#!/bin/bash`...). Notes of `key: value` lines are not YAML; a sentence mentioning "select ... from" is not SQL.
+- Only plain-text pastes are guessed: when the clipboard carries formatted text (headings, lists, links, bold from a web page), it is pasted with its formatting as before and nothing is offered. Nothing is offered where nothing would be added (see above): Markdown into a note that is already `@markdown`, code into `@code=…`, CSV into `@csv`.
+- The card moves nothing and never takes the keyboard: the caret stays where the paste ended. `Skip`, `Escape` (which closes only the card, not edit mode), typing on, a click elsewhere, scrolling the page yourself, or leaving edit mode closes it without applying; when MetaList scrolls on its own (a new note settling into view) the card stays with the paste. Near the bottom of the window it opens above the paste instead; the page never scrolls to show it.
+- Pasting while no note is edited makes a new note at the top, as before; its paste is checked the same way (certain formats tagged at once, likely ones offered on the card once the new note is in place).
+- `Apply` adds the tag as a detected format is added: the plain tag into an otherwise empty note, or the paste wrapped `((...))` with `((@markdown))` into a note with other text. The note stays in edit mode and the text renders when it leaves editing. `⌘Z` right after removes the tag together with the paste, as for a format added at once.

{metalist-0.18.0 → metalist-0.19.0}/app/services/agent/skills/help-notes.md

@@ -172,7 +172,7 @@ On macOS, `⌘ + Y` normally opens Safari History rather than performing native
 | Right-click image in note | Adds image actions to the note context menu: `Copy Image`, `Save Image`, `Zoom Image`, `Open Image in New Tab` |
 | Right-click anywhere in a completed AI response bubble (including padding and links) | Choose `Copy Response` to place its raw Markdown on the MetaList note clipboard with `@markdown @llm`, while also writing rendered HTML and raw Markdown to the system clipboard. It can be pasted as a note but not as a reference until inserted. |
 | Right-click notes view background | Open the view menu: outside edit mode `Add Note at Top`, `Paste Note at Top` (once a note is copied), `Undo`, `Redo`; `Go to Top`, `Go to Bottom` (unless at that end), `Fully Expand All`, `Fully Collapse All`; `View ▸` (All / Untagged notes), `Sort by ▸`, `Show ▸` (Chat, Tabs, Tags in List), `Theme ▸` (System, Light, Dark), each ticking the current choice; `New Tab`, `Open/Switch Namespace…`, `Reminders…`; `Export View as HTML`; `Log Out`. Shortcuts show on the right; items that do not apply are hidden. |
-| Right-click tag in search input, tag bar, or their suggestion lists | Open tag context menu (Edit Tag Relationships); a suggestion's menu (tag bar or search) starts with **Why suggested**. A suggestion list, the typed letters and edit mode stay as they were. Choosing Edit Tag Relationships saves an edited note first and completes the view refresh, restoring view-only rendering such as cached URL titles. |
+| Right-click tag in search input, tag bar, or their suggestion lists | Open tag context menu (Edit Tag Relationships); below it a suggestion's menu (tag bar or search) says **Why suggested**, a tag already in the tag bar or search box **About this tag**. A suggestion list, the typed letters and edit mode stay as they were. Choosing Edit Tag Relationships saves an edited note first and completes the view refresh, restoring view-only rendering such as cached URL titles. |
 | Right-click left or right lane | Open the same view menu |
 | Hover left side of search bar | Show the tab/search-context overlay |
 | Hover/click search input | Hide the tab/search-context overlay |

{metalist-0.18.0 → metalist-0.19.0}/app/services/agent/skills/help-releases.md

@@ -5,6 +5,15 @@ README. Changes made after the newest listed version are not described here.
 Compare with installed_version from the help lookup to tell the user whether
 they already have a release. Version info offers updates (see the data topic).
 
+## 0.19.0
+
+- Paste formats: pasting a fenced code block that names its language tags the note `@markdown`, and `@markdown` now colours that code like `@code=<language>` (with its label). Code copied from VS Code is tagged `@code=<its language>`, and cells copied from Excel, Google Sheets or Numbers become CSV text tagged `@csv`.
+- Text that only looks like a format is offered, not applied: after pasting CSV-like, Markdown-like or code-like text, a small card says "Apply as CSV" / "Apply as Markdown" / "Apply as Python" (up to three close languages for code) with "Skip". The card moves nothing and never takes the keyboard; typing on, Escape or a click elsewhere closes it. It also appears when the paste makes a new note.
+- Right-click a tag already in the tag bar or the search box for **About this tag**: whether the note names it, the notes it shares with your other tags, whether a parent or a rule already gives it, its synonyms and implications, how many notes have it ("Only on this note" hints at a typo); in the search box, what it finds and what leaving it out removes. Edit Tag Relationships now comes first in the tag menu, at a fixed place under the pointer.
+- Tag suggestions: a web address in a note counts only by its site's name, so a YouTube link no longer suggests `HTTPS` or `V-neuron`; one letter alone no longer names a tag with longer words. A suggestion without evidence now says only what is true (what you typed matches, which part of its name the note has) instead of "Nothing in this note points to it".
+- Fixed: accepting a Grammarly suggestion while editing could undo itself and end editing, when Grammarly drew its card in an element MetaList did not recognise.
+- Removed the "Make pseudo-suggestions" test item from the note menu.
+
 ## 0.18.0
 
 - Right-click a tag suggestion, in the tag bar or the search bar, to see why it is suggested. The menu starts with **Why suggested**: the words of the note that name the tag (or a synonym), the tags it goes with and on how many notes, notes sharing this note's tags, whether it already applies through a parent or a rule, or that nothing in the note points to it; then how often the tag is used. Search suggestions also say how often you worked with a tag lately (when that put it first), what your search so far finds, or what leaving it out removes. The reasons are MetaList's own ranking, not the AI's, and appear instantly.

{metalist-0.18.0 → metalist-0.19.0}/app/services/agent/skills/help-search.md

@@ -144,8 +144,9 @@ Ontology rules also add **inferred tags** before search matching:
 - A typed prefix can match either the start of the full tag or the start of any connector-separated segment.
   - Example: `wor` suggests `workspaces` and `databricks-workspaces`.
   - Example: `orksp` suggests neither.
-- Right-clicking a search suggestion (Control-click on a Mac) opens its tag menu: **Why suggested**, then Edit Tag Relationships. The search and the list stay as they were; `Escape` closes only the menu. A right-click earns no activity credit.
+- Right-clicking a search suggestion (Control-click on a Mac) opens its tag menu: Edit Tag Relationships, then **Why suggested** below it. The search and the list stay as they were; `Escape` closes only the menu. A right-click earns no activity credit.
 - **Why suggested** says what MetaList's ranking used (not the AI): how often you worked with the tag in a personalization window (`You've worked with it 12 times in the last 7 days`), the notes it shares with the tags already in the search, how many notes the search so far finds it on, how many notes leaving it out removes, or that a first tag is listed by use; last, how many notes searching for it finds.
+- Right-clicking a tag already typed in the search box opens its menu with **About this tag** below Edit Tag Relationships: how many notes searching for it finds (or `No note has this tag`, often a typo), how many notes it shares with the other tags in the search, what leaving out a `-tag` removes, which synonyms and implying tags it also finds, and how often you worked with it recently.
 - The server returns at most `MAX_SEARCH_SUGGESTIONS` suggestions; the default is 20.
 - This affects suggestions only; actual tag search matching remains exact against effective tag terms.
 

{metalist-0.18.0 → metalist-0.19.0}/app/services/agent/skills/help-tags.md

@@ -152,7 +152,8 @@ Unclosed comments behave like unclosed wrappers:
 - Connector-heavy tags need near-complete literal coverage before they surface from content alone: after ignoring numeric-only chunks, a tag with `k` remaining connector-separated chunks requires at least `max(1, k-1)` meaningful matches, capped by its number of meaningful non-noise chunks. Thus `gpt-6-astra` behaves like `gpt-astra`: either `GPT` or `Astra` can surface it. Decimal versions such as `5.6` are ignored in the same way. `X-Y-Z` still needs two matches and cannot surface from just `X`, `Y`, or `Z`.
 - Numeric chunks remain insufficient on their own, but they count inside a contiguous near-complete connector phrase that also contains a meaningful text chunk. For example, content `5.6 sol` can promote `GPT-5.6-sol`, while content `5.6` alone does not promote `GPT-5.6`.
 - When content matches connector-separated tags, the candidate covering the longest contiguous portion of the note wins first. Fewer unmatched connector segments rank ahead of more padded tags, and prefix-aligned partials beat suffix-aligned ones when coverage otherwise ties. Examples: `A B C D` prefers `B-C-D` over `C-D`, `Z` prefers `Z` over `Y-Z`, `Y` prefers `Y-Z` over `X-Y`, and `Y Z` prefers `Y-Z` over `Z` over `X-Y-Z`.
-- Single-character connector segments are still ignored for lowercase noise like `a-b-test`. Uppercase one-letter segments can still count as meaningful literals for entity-like tags, but prose-like `A` and `I` are treated as noise so they do not boost unrelated suggestions.
+- Single-character connector segments are still ignored for lowercase noise like `a-b-test`. Uppercase one-letter segments can still count as meaningful literals for entity-like tags, but prose-like `A` and `I` are treated as noise so they do not boost unrelated suggestions. One letter alone never names a tag that also has longer words: a stray `v` does not surface `V-neuron` or `V-Shred` (with `shred` also in the text, `V-Shred` is named). Tags made only of letters (`X-Y-Z`, `Z`) still match.
+- A web address in the note's text counts only by its site's name: `https://www.youtube.com/watch?v=GYx4…` reads as `youtube`, so it can name a `YouTube` tag but not `HTTPS`, `V-neuron` or `indeed.com`. The scheme, `www`/`m`, the top-level domain (and `co.uk`-style suffixes), the path and the query are dropped; an IP address has no name. Only addresses with a scheme or a leading `www.` count as addresses: `indeed.com` written in prose still names the tag.
 - When content-hit strength ties, more structured/specific tags rank ahead of broader/common ones. Mixed-case tags, digit-bearing tags, connector-separated tags, and prefix-aligned segment matches beat looser matches; usage frequency then breaks structurally equal ties before content position, raw tag length, or alphabetical ordering.
 - Surrounding prose punctuation is ignored for content matching, so content like `(github?)` still promotes the `github` tag.
 - Possessive words also match the base tag: `Julie's birthday is today...` promotes the existing `Julie` tag. Straight and curly apostrophes are equivalent, and full tags containing apostrophes (such as `goat's-milk`) still match normally.
@@ -161,17 +162,19 @@ Unclosed comments behave like unclosed wrappers:
 - Tags declared in ontology rules remain eligible for literal-content matching and typed-prefix completion even when they have never been explicitly assigned to a note. With a blank prefix, unrelated unused ontology tags are not added as generic fallback suggestions.
 - Tags already present explicitly in the current tag bar are never suggested.
 - Tags already present only via inheritance or ontology inference are suppressed unless they match the prefix. For one-character prefixes they come right after the suggestions with evidence; for longer prefixes they appear at the bottom. The **Tag Suggestions** settings dialog has `Allow suggesting tags that already apply` (off by default): when on, tags a parent already has and tags the rules imply from them are ranked like any other tag. Tags written in the note's own bar are still never suggested.
-- Right-clicking a suggestion (Control-click on a Mac) opens the tag menu for it: **Why suggested**, then Edit Tag Relationships. The list, the typed letters and edit mode stay as they were; `Escape` closes only the menu.
-- **Why suggested** says what the ranking found, then how often the tag is used: named (or partly named) in the note's text, a synonym named in it, the rest of the tag after what was typed, on N notes together with the note's tags, named in the note as last saved, on N notes that share the note's tags, or already applying through a parent or a rule. `Nothing in this note points to it` means it is listed only because it is used often. The reasons are MetaList's own ranking, not the AI's.
+- Right-clicking a suggestion (Control-click on a Mac) opens the tag menu for it: Edit Tag Relationships, then **Why suggested** below it. The list, the typed letters and edit mode stay as they were; `Escape` closes only the menu.
+- **Why suggested** says what the ranking found, then how often the tag is used: named (or partly named) in the note's text, a synonym named in it, the rest of the tag after what was typed, on N notes together with the note's tags, named in the note as last saved, on N notes that share the note's tags, or already applying through a parent or a rule. `Listed by use` means the ranking found no evidence in this note, so it is listed because it is used often; `Part of its name is in this note's text` then shows the words that are there but too few to count. The reasons are MetaList's own ranking, not the AI's.
 - Suggestions appear below the tag bar when there is room; if the tag bar is near the bottom, the list flips upward but keeps the same best-on-top ordering and initial scroll position.
 - The server returns at most `MAX_TAG_SUGGESTIONS` note tag suggestions; the default is 20.
 
+## About This Tag
+- Right-clicking a tag already in the tag bar opens its menu with **About this tag** below Edit Tag Relationships (facts, since it may never have been suggested): whether the note's text names it, how many other notes have it together with this note's other tags, whether a parent or a rule already gives it (writing it repeats that), its synonyms and what it implies, and how many notes have it. `Only on this note` can mean a typo or a one-off tag; `Not on any saved note yet` means it was just typed.
+
 ## AI Tag Proposals
 
 - Unresolved proposals are stored separately from accepted tags. They affect inheritance, ontology-aware search/autocomplete, and Untagged Notes immediately, but do not activate formatting or tag commands.
-- Right-clicking the actively edited note exposes **Make pseudo-suggestions**, which adds a deterministic temporary test set to that note only.
 - Direct proposals appear beneath the tag bar only while their note is edited. `+` accepts a proposal into the ordinary tag bar; `−` rejects it.
-- The current single-note **Make pseudo-suggestions** test action and individual proposal accept/reject controls participate in normal undo/redo; undoing an individual acceptance restores its proposal and robot count, while redo accepts it again. This does not define undo behavior for bulk operations.
+- Individual proposal accept/reject controls participate in normal undo/redo; undoing an individual acceptance restores its proposal and robot count, while redo accepts it again. This does not define undo behavior for bulk operations.
 - The robot count marks unresolved proposals on visible notes. A collapsed note rolls up proposals hidden in its descendant branch; inherited and ontology-derived terms do not inflate the count.
 - Copy/paste and duplication preserve each note's direct unresolved proposals.
 - The connector characters used for content matching are configurable via `TAG_SUGGESTION_CONNECTORS` in `app/config.py`.
@@ -179,7 +182,7 @@ Unclosed comments behave like unclosed wrappers:
 
 ### Bulk proposal operations
 
-Chat-requested LLM generation and menu/chat bulk acceptance or rejection use a separate atomic path from the single-note pseudo-suggestion test action above. See [agent tagging](../design/agent-harness.md#tag-proposal-operations).
+Chat-requested LLM generation and menu/chat bulk acceptance or rejection use a separate atomic path from the individual proposal controls above. See [agent tagging](../design/agent-harness.md#tag-proposal-operations).
 
 - Bulk operations are outside ordinary undo/redo, even when applied atomically. They create no individual or combined undo entry and expose no bulk Undo control.
 - Successful application clears the existing undo and redo stacks using the search-context boundary mechanism. Failure, cancellation, or decline preserves the stacks. A result with no changes preserves history.

{metalist-0.18.0 → metalist-0.19.0}/app/services/code_rendering.py

@@ -24,6 +24,8 @@ CODE_LANGUAGE_RE = re.compile(r"[a-z0-9][a-z0-9+#._-]*")
 # Every name and alias Pygments knows (python, py, js, javascript, c++...).
 _KNOWN_LANGUAGES = frozenset(alias for _name, aliases, _patterns, _mimetypes in get_all_lexers() for alias in aliases)
 _FORMATTER = HtmlFormatter(nowrap=True, classprefix="tok-")
+# Fence names that mean "no language": a Markdown fence naming one stays plain.
+_PLAIN_FENCE_LANGUAGES = frozenset({"text", "txt", "plain", "plaintext", "output", "console", "none", "nohighlight"})
 
 
 def parse_code_tag_language(tag_name: str) -> str | None:
@@ -61,13 +63,37 @@ def render_code_meta(*, content_html: str, language: str, formatting_tags: Froze
             f'<pre class="meta-code-pre"><code class="{code_class}">{html.escape(raw_text, quote=False)}</code></pre>'
             "</div>"
         )
+    return _highlighted_block(raw_text=raw_text, language=language, label=language, code_class=code_class, copy_attr=copy_attr)
+
+
+def is_highlighted_fence_language(language: str) -> bool:
+    """Whether a Markdown fence naming this language is highlighted (any case, aliases too)."""
+    if not isinstance(language, str):
+        raise TypeError("language must be a string")
+    folded = language.casefold()
+    return folded not in _PLAIN_FENCE_LANGUAGES and is_known_code_language(folded)
+
+
+def render_fenced_code(*, code: str, language: str) -> str:
+    """A Markdown fence's code, highlighted and labelled as @code=<language> renders it."""
+    if not is_highlighted_fence_language(language):
+        raise ValueError(f"Fence language is not highlighted: {language!r}")
+    return _highlighted_block(
+        raw_text=code, language=language.casefold(), label=language, code_class="meta-code-code", copy_attr="",
+    )
+
+
+def _highlighted_block(*, raw_text: str, language: str, label: str, code_class: str, copy_attr: str) -> str:
     highlighted = highlight(raw_text, get_lexer_by_name(language), _FORMATTER).rstrip("\n")
     return (
         f'<div class="meta-code"{copy_attr}>'
-        f'<span class="meta-code-language">{escaped_language}</span>'
+        f'<span class="meta-code-language">{html.escape(label, quote=True)}</span>'
         f'<pre class="meta-code-pre"><code class="{code_class}">{highlighted}</code></pre>'
         "</div>"
     )
 
 
-__all__ = ["CODE_TAG_PREFIX", "is_known_code_language", "parse_code_tag_language", "render_code_meta"]
+__all__ = [
+    "CODE_TAG_PREFIX", "is_highlighted_fence_language", "is_known_code_language", "parse_code_tag_language",
+    "render_code_meta", "render_fenced_code",
+]

{metalist-0.18.0 → metalist-0.19.0}/app/services/markdown_rendering.py

@@ -6,6 +6,8 @@ from dataclasses import dataclass
 from typing import List
 from urllib.parse import urlsplit
 
+from app.services.code_rendering import is_highlighted_fence_language
+from app.services.code_rendering import render_fenced_code
 from app.services.latex_rendering import render_latex_math_to_html
 
 
@@ -127,6 +129,9 @@ class _MarkdownRenderer:
                 "</pre>"
             )
 
+        # A language Pygments knows is coloured as @code=<language>; others stay plain.
+        if language != "" and is_highlighted_fence_language(language):
+            return render_fenced_code(code="\n".join(content_lines), language=language)
         language_attr = ""
         if language != "":
             escaped_language = html.escape(language, quote=True)

{metalist-0.18.0 → metalist-0.19.0}/app/services/search_history.py

@@ -656,6 +656,31 @@ def list_recent_search_tag_selections_for_first_query(
     )
 
 
+def count_recent_tag_activity(
+    *, tag: str, window_days: tuple[int, ...], token: str, today: date,
+) -> list[TagActivityWindowSelection]:
+    """The tag's activity credits in each window that has any, in window order."""
+    if not isinstance(tag, str) or tag == "":
+        raise ValueError("tag must be a non-empty string")
+    validate_tag_activity_windows(window_days)
+    counts_by_date = search_history_store.copy_daily_counts(token=token)
+    tag_casefold = tag.casefold()
+    windows: list[TagActivityWindowSelection] = []
+    for day_count in window_days:
+        earliest_day = today - timedelta(days=day_count - 1)
+        total = 0
+        for day_text, tag_counts in counts_by_date.items():
+            activity_day = date.fromisoformat(day_text)
+            if activity_day < earliest_day or activity_day > today:
+                continue
+            for tag_name, count in tag_counts.items():
+                if tag_name.casefold() == tag_casefold:
+                    total += count
+        if total > 0:
+            windows.append(TagActivityWindowSelection(tag=tag, window_days=day_count, activity_count=total))
+    return windows
+
+
 def reset_search_history(*, token: str) -> int:
     if not isinstance(token, str) or token == "":
         raise ValueError("token must be a non-empty string")

{metalist-0.18.0 → metalist-0.19.0}/app/services/search_index.py

@@ -549,23 +549,27 @@ class SearchIndex:
                 if term and not term.startswith("@")
             }
 
-    def describe_tag_cooccurrence(self, *, anchors: Iterable[str], terms: Iterable[str]) -> Dict[str, TagCooccurrence]:
+    def describe_tag_cooccurrence(
+        self, *, anchors: Iterable[str], terms: Iterable[str], excluded_note_ids: FrozenSet[str],
+    ) -> Dict[str, TagCooccurrence]:
         """For each term, the notes carrying it together with the most of the anchors.
 
         The same measure `suggest_tag_completions` ranks by (the most anchors one
         of the term's notes carries, and how many notes carry that many), with
         the anchors named. Terms on no note with an anchor are left out.
+        excluded_note_ids: notes not to count (the note a tag is already on).
         """
         anchor_casefold_set = frozenset(
             anchor.casefold() for anchor in anchors if anchor and not anchor.startswith("@")
         )
         described: Dict[str, TagCooccurrence] = {}
         with self._lock:
+            excluded = {self._uuid_to_id[note_id] for note_id in excluded_note_ids if note_id in self._uuid_to_id}
             for term in terms:
                 term_casefold = term.casefold()
                 if term_casefold not in self._tag_notes_casefold:
                     continue
-                term_notes = self._tag_notes_casefold[term_casefold]
+                term_notes = self._tag_notes_casefold[term_casefold] - excluded
                 anchors_by_note: Dict[int, Set[str]] = {}
                 for anchor_casefold in anchor_casefold_set:
                     if anchor_casefold == term_casefold or anchor_casefold not in self._tag_notes_casefold:
@@ -604,7 +608,9 @@ class SearchIndex:
                     posting = frozenset(self._tag_notes_casefold[term.casefold()])
                 note_counts[term] = len(posting)
                 matching_counts[term] = len(posting & matching_ids)
-            cooccurrences = self.describe_tag_cooccurrence(anchors=context.anchors, terms=shown)
+            cooccurrences = self.describe_tag_cooccurrence(
+                anchors=context.anchors, terms=shown, excluded_note_ids=frozenset(),
+            )
             return SearchSuggestionFacts(
                 partial_prefix=partial_prefix, anchors=tuple(context.anchors),
                 has_completed_clause=has_completed_clause, is_exclusion=context.is_exclusion,
@@ -612,6 +618,22 @@ class SearchIndex:
                 matching_counts=matching_counts, cooccurrences=cooccurrences,
             )
 
+    def count_tag_within_search(self, *, term: str, search: str) -> Tuple[int, int]:
+        """(notes the search finds, how many of them carry the tag); a blank search finds every note."""
+        if not isinstance(term, str) or term == "":
+            raise TypeError("term must be a non-empty string")
+        if not isinstance(search, str):
+            raise TypeError("search must be a string")
+        with self._lock:
+            if search.strip() == "":
+                found = set(self._alive)
+            else:
+                found = {self._uuid_to_id[note_id] for note_id in self.query_note_ids(search)}
+            posting: Set[int] = set()
+            if term.casefold() in self._tag_notes_casefold:
+                posting = self._tag_notes_casefold[term.casefold()]
+            return len(found), len(found & posting)
+
     def count_notes_with_tag(self, term: str) -> int:
         """Notes carrying the tag, as suggestions count usage (case-insensitive)."""
         if not isinstance(term, str) or term == "":