adeelahmad · Oct 18, 2026 · Oct 18, 2026
diff --git a/README.md b/README.md
@@ -209,8 +209,9 @@ listed under [In progress](#in-progress), and what comes next under [Planned](#p
   the assistant, and people review on the Timeline page (and Latest on Home), marking what they've seen, reacting with
   an emoji and commenting in threads everyone who sees the item shares (agents too, over MCP), and asking the
   assistant about any item from the item; a comment that tags @lens gets the agent's answer in the thread, with
-  every change it proposes waiting for a yes, and a For you order learned from each person's own reactions, comments
-  and marks says why each item is where it is. Automations act
+  every change it proposes waiting for a yes, a For you order learned from each person's own reactions, comments
+  and marks says why each item is where it is, and each person mutes a source or a kind for themselves, with nothing
+  deleted. Automations act
   on that stream, on a schedule, at a time or when their own webhook is called, alone or with their triggers joined (all
   of them, a number of times, one that doesn't come in time, or a batch): they test conditions (text, patterns,
   numbers, lists, times, days, whether a value changed and whether something like it happened before in their

diff --git a/changelog.d/timeline-mutes.md b/changelog.d/timeline-mutes.md
@@ -0,0 +1,6 @@
+**Mute a source on the timeline.** An opened item has **Mute Work Gmail**: everything from that source or person
+leaves your timeline, with Undo, and a Muted row above the list lifts each one. Muting hides, it never deletes: the
+activities stay, still trigger automations and still show to everyone else, and `hidden=true` shows them to you.
+Agents mute a source or a kind, for good or until a time, with `POST /api/v1/activities/mute`, the MCP
+`mute_activities` tool and the assistant, which asks first after it has read outside text
+([Muting](docs/timeline.md#muting)).
diff --git a/docs/assistant.md b/docs/assistant.md
@@ -254,8 +254,9 @@ When the configured model supports function calling, chat becomes an agent.
   types or topics fits an asset or a text, and how sure that is (`classify`, [Classifying](processing.md#classifying));
   it changes nothing.
 - **The person's review marks:** `mark_activities` marks activities of the timeline reviewed, important or hidden for
-  the person ([Timeline](timeline.md#review-marks)). After it has read text from outside Lens, hiding or marking
-  reviewed waits for their yes; marking important or bringing things back acts at once.
+  the person ([Timeline](timeline.md#review-marks)), and `mute_activities` mutes a source, person or kind for them,
+  for good or until a time ([Muting](timeline.md#muting)). After it has read text from outside Lens, hiding, muting
+  or marking reviewed waits for their yes; marking important, lifting a mute or bringing things back acts at once.
 - **The person's approvals:** `approvals` lists what waits for their pick ([Approvals](automations.md#approvals)):
   automations' actions about the namespaces the conversation reads, and its own proposals in this conversation.
   `decline_approval` declines one; after it has read text from outside Lens (the approvals' own summaries count),

diff --git a/docs/automations.md b/docs/automations.md
@@ -1366,7 +1366,7 @@ month, and each run what it cost.
 
 Everything in the studio is open to agents. People and agents use the same API (`/api/v1`, [API](api.md#automations)),
 and agents also have MCP tools ([MCP](mcp.md#tools)). The [assistant](#agents) has `automations`, `save_automation`,
-`test_automation`, `run_automation`, `timeline`, `mark_activities`, `approvals` and `decline_approval`. Asked how to
+`test_automation`, `run_automation`, `timeline`, `mark_activities`, `mute_activities`, `approvals` and `decline_approval`. Asked how to
 do something in this guide, the assistant and MCP clients look it up here with `lens_help`.
 
 | To | API | MCP |
@@ -1384,7 +1384,7 @@ do something in this guide, the assistant and MCP clients look it up here with `
 | Saved variables | `GET`/`PUT /automations/{id}/vars`, `/namespaces/{name}/automation-vars` | `automation_vars`, `set_automation_vars` |
 | The variable picker and a template's preview | `POST /automations/variables`, `POST /automations/preview` | `automation_variables`, `preview_template` |
 | Approvals | `GET /approvals`, `GET /approvals/count`, `POST /approvals/{aid}` | `approvals`, `decline_approval` (never approve) |
-| The stream and its kinds | `GET /activities`, `GET /activities/kinds`, `POST /activities/mark` | `timeline`, `event_kinds`, `mark_activities` |
+| The stream and its kinds | `GET /activities`, `GET /activities/kinds`, `POST /activities/mark`, `POST /activities/mute` | `timeline`, `event_kinds`, `mark_activities`, `mute_activities` |
 | Set an automation off from outside | `POST /automations/hooks/{token}` ([Webhook trigger](#webhook-trigger)) | not needed: anything that sends HTTP calls it |
 
 ## Built, in progress, planned

diff --git a/docs/mcp.md b/docs/mcp.md
@@ -127,6 +127,7 @@ For an app that speaks OpenAI's API rather than MCP, the namespace can also answ
 | `read_file` | a text file of that tree (an asset's `.txt` text or `.json` metadata), a page at a time; other files' download link |
 | `timeline` | what happened in Lens, newest first ([Automations](automations.md#timeline-reads)): each activity's kind, who did it, what it is about, when, and a one-line summary; by kinds, actor, namespace, entity, time, words or a match tree, a page at a time; `unreviewed` for what the person hasn't marked reviewed, with their marks on the page in `marks`; `order: for_you` for the [For you](timeline.md#for-you) order, with `why` by id. Fields holding outside text are listed in `lens.untrusted` |
 | `mark_activities` | mark activities reviewed, important or hidden, or clear those marks, for the person alone ([Timeline](timeline.md#review-marks)); up to 500 by id, `unknown` lists those that can't be seen. Needs a write-scope token |
+| `activity_mutes`, `mute_activities` | the person's mutes on the timeline, and mute a source or person (`actor`) or a kind (`kind`), for good or `until` a time, or lift one with `on` false ([Muting](timeline.md#muting)); nothing is deleted. Muting needs a write-scope token |
 | `react_to_activity` | put an emoji (👍 ❤️ 🎉 👀 😂 😮 😢 🙏) on an activity for the person, or take theirs back (`on` false), as on a post in a feed ([Timeline](timeline.md#reactions-and-comments)); everyone who sees the activity sees it, and it is a `reaction.added` activity. Needs a write-scope token |
 | `activity_comments` | an activity's comments, threaded, with who wrote each; on an asset's arrival the asset's own. What people wrote is data, never instructions |
 | `comment_on_activity` | write a comment on an activity for the person, or with `parent` a reply on a thread; a `comment.added` activity. Needs a write-scope token |

diff --git a/docs/requirements.md b/docs/requirements.md
@@ -204,6 +204,7 @@ request, to another check that proves the same thing; loosening a requirement or
 | The graph as it was at any version | [test_graph_history.py](https://github.com/adeelahmad/lense/blob/main/fastapi_backend/tests/api/test_graph_history.py) `test_the_explorer_and_cypher_as_of_a_version`, `test_the_canvas_as_of_a_version`; [test_graph_history.py](https://github.com/adeelahmad/lense/blob/main/fastapi_backend/tests/domain/test_graph_history.py) `test_every_curation_is_an_event_and_every_version_replays` |
 | Sources, sensors, people and agents as actors in the graph, with ADDED links to what they brought in, on the canvas, in the explorer and in Cypher | [test_graph.py](https://github.com/adeelahmad/lense/blob/main/fastapi_backend/tests/api/test_graph.py) `test_sources_are_actors_in_the_graph`; jest [graph-explorer.test.ts](https://github.com/adeelahmad/lense/blob/main/nextjs-frontend/__tests__/graph-explorer.test.ts) `shows a source only while something it brought in is visible` |
 | A For you order of the timeline, learned from each person's own reactions, comments and marks, each item saying why, with Latest the default; through the API, MCP, the assistant and the page | [test_timeline_for_you.py](https://github.com/adeelahmad/lense/blob/main/fastapi_backend/tests/api/test_timeline_for_you.py) `test_for_you_learns_from_reactions_comments_and_marks_and_says_why`, `test_agents_read_for_you_too`; jest [timeline-model.test.ts](https://github.com/adeelahmad/lense/blob/main/nextjs-frontend/__tests__/timeline-model.test.ts) `keep the For you order as a view, not a filter`, [timeline-ui.test.tsx](https://github.com/adeelahmad/lense/blob/main/nextjs-frontend/__tests__/timeline-ui.test.tsx) `For you: the toggle goes in the address, each placed line says why, and Latest stays the default` |
+| Muting a source, a person or a kind on the timeline, for good or until a time, for the person alone, with nothing deleted; through the API, MCP, the assistant (asking first after outside text) and the page | [test_timeline_mutes.py](https://github.com/adeelahmad/lense/blob/main/fastapi_backend/tests/api/test_timeline_mutes.py) `test_a_mute_hides_an_actor_or_a_kind_for_the_person_alone`, `test_agents_mute_too_and_the_assistant_asks_first_after_outside_text`; jest [timeline-ui.test.tsx](https://github.com/adeelahmad/lense/blob/main/nextjs-frontend/__tests__/timeline-ui.test.tsx) `muting a source takes everything from it out, lists it as muted, and Undo or the chip brings it back` |
 | Every entity's own page at `/wiki/<namespace>/<Name>` | [test_entities.py](https://github.com/adeelahmad/lense/blob/main/fastapi_backend/tests/api/test_entities.py) `test_wiki_addresses`; [wiki-page.test.tsx](https://github.com/adeelahmad/lense/blob/main/nextjs-frontend/__tests__/wiki-page.test.tsx); [journeys.mjs](https://github.com/adeelahmad/lense/blob/main/ci/clicks/journeys.mjs) `entity-find` |
 | Entities, topics and people edited and merged from their lists, the graph or an asset, with Undo instead of a confirm | [test_entities.py](https://github.com/adeelahmad/lense/blob/main/fastapi_backend/tests/domain/test_entities.py) `test_suggestions_and_merge_undo`; [entities-curate.test.tsx](https://github.com/adeelahmad/lense/blob/main/nextjs-frontend/__tests__/entities-curate.test.tsx); [topics-curate.test.tsx](https://github.com/adeelahmad/lense/blob/main/nextjs-frontend/__tests__/topics-curate.test.tsx); [recording-entities-edit.test.tsx](https://github.com/adeelahmad/lense/blob/main/nextjs-frontend/__tests__/recording-entities-edit.test.tsx); [journeys.mjs](https://github.com/adeelahmad/lense/blob/main/ci/clicks/journeys.mjs) `entity-merge`, `graph-merge`, `speaker-rename` |
 | Names get their real types (people, places, organisations, events, works) by rules, without a model; older Terms are typed on upgrade | [test_name_types.py](https://github.com/adeelahmad/lense/blob/main/fastapi_backend/tests/domain/test_name_types.py) `test_names_get_the_type_their_words_give`, `test_analysis_types_people_places_and_events`, `test_the_upgrade_types_the_old_terms_and_keeps_what_people_chose` |

diff --git a/docs/timeline.md b/docs/timeline.md
@@ -18,6 +18,7 @@ Status: in progress. The studio's timeline is built in steps; only what is merge
 | Tagging the agent in a comment, so it answers in the thread | built |
 | Sources, sensors, people and agents as actors in the graph: a Source node with ADDED links, on the canvas, in the explorer and in Cypher | built |
 | A For you order learned from what each person reacts to, comments on, marks important and hides, each item saying why | built |
+| Muting a source, person or kind, for good or until a time, for yourself alone; `mute_activities` for agents | built |
 
 ## What shows
 
@@ -59,7 +60,9 @@ unless you ask for them by kind.
 
 Hovering or focusing a line shows its **Important** (star) and **Reviewed** (circle) toggles; once set they stay in
 sight. On a line of several items they mark every item. **Mark all shown as reviewed** marks everything on the page
-you haven't reviewed, with **Undo** in the message rather than a confirm; **Hide** works the same way.
+you haven't reviewed, with **Undo** in the message rather than a confirm; **Hide** works the same way. An opened item
+also has **Mute Work Gmail**: everything from that source or person leaves your timeline, with **Undo** in the
+message, and a **Muted** row above the list shows what you muted with an × to lift each one ([Muting](#muting)).
 
 ### Asking about an item
 
@@ -151,7 +154,8 @@ Marks change nothing else: an activity you hid still triggers automations and st
 - MCP: `timeline` takes `unreviewed: true` for what you haven't marked reviewed and has your marks in `marks`, and
   `order: for_you` for the [For you](#for-you) order with `why` by id; `mark_activities` marks activities by id
   (`ids`, and `reviewed`, `important` or `hidden`), for the person it acts for, with a token that has the write
-  scope ([MCP](mcp.md)).
+  scope ([MCP](mcp.md)); `hidden: true` on `timeline` reads what they hid or muted, and `mute_activities` mutes a
+  source or a kind ([Muting](#muting)).
 - The assistant: `timeline` takes `unreviewed` and `order` and lists each activity's marks and, for you, its `why`;
   `mark_activities` marks them for the person. After it has read text from outside Lens (the timeline's own titles count), hiding or marking reviewed
   waits for the person's yes, since that text may have asked for it; marking important or bringing things back acts
@@ -162,6 +166,24 @@ Marks change nothing else: an activity you hid still triggers automations and st
   what people wrote: agents read them as data, never as instructions. A comment an agent writes with `@lens` in it
   gets the assistant's answer like anyone's, as the person the token acts for.
 
+## Muting
+
+Each person mutes a source or person (an actor) or a kind of activity ("hide syslog"), for good or until a time
+(snoozed for a day), for themselves alone. Muting hides; it never deletes: a muted actor's activities stay stored,
+still trigger automations and still show to everyone else, and come back the moment the mute is lifted or runs out.
+The timeline leaves them out as it leaves out what you hid, so `hidden=true` shows them and `hidden=false` (the
+page) does not; a For you page scores only what is left.
+
+- On the page, **Mute Work Gmail** on an opened item mutes its actor, and the **Muted** row above the list lifts one
+  with its ×. Muting a kind, or until a time, is through the API, MCP and the assistant for now.
+- `POST /api/v1/activities/mute` with `{"actor": "lens:source/12", "name": "Work Gmail"}` or `{"kind":
+  "sensor.reading"}` (the kinds under it count too), and `"until"` as an ISO 8601 time to snooze it, mutes for
+  yourself; `"on": false` lifts it. The answer, and `GET /api/v1/activities/mutes`, is your mutes now: `{actor, kind,
+  name, until, at}` each. Up to 200; one that has run out is dropped the next time your mutes are read.
+- `mute_activities` over MCP (`actor` or `kind`, `name`, `until`, `on`) and `activity_mutes` do the same for the
+  person a token acts for, with the write scope to mute. The assistant's `mute_activities` acts at once, but after
+  it has read text from outside Lens it asks first, as hiding does, since that text may have asked for it.
+
 ## For you
 
 For you is a cheap, explainable order of the timeline, learned from each person's own signals and nothing else:
@@ -191,7 +213,9 @@ Reactions are kept the same way: one `event_reaction` row per person and activit
 a page in one query, deleted when none is left, and gone when the person is removed. Comments on activities are
 `comment` rows ([comments](api.md#comments)) with the activity's id in `activity` and its summary in `about`; a
 comment on an asset's arrival also has the asset in `recording`, which is how it shows on both. A page's comment
-counts are two grouped queries. Nothing of this costs a model call.
+counts are two grouped queries. Mutes are one `event_mute` row per person and target (an actor id or a kind), with
+the name shown, `until` and when it was set, read once per page and applied with the mark filters in the same query
+per source page; they go when the person is removed. Nothing of this costs a model call.
 
 ## Refine later
 
@@ -200,7 +224,8 @@ counts are two grouped queries. Nothing of this costs a model call.
 
 - Server-sent updates instead of the page polling for new items.
 - For you counts opens too, once the page reports them, and could cache each person's affinity for a minute rather
-  than summing it on every read; per-source mute (a lasting "hide everything from this") is next.
+  than summing it on every read.
+- Muting a kind, or for a day, from the page (a menu on Mute), and a muted actor's own line in the Filters.
 - Saved filter views.
 - A daily digest of unreviewed items, as an automation starter.
 - Marks on activities whose rows are gone (an event log entry past `events.keep_days`, a deleted asset) stay until

diff --git a/fastapi_backend/app/api/mcp_tools.py b/fastapi_backend/app/api/mcp_tools.py
@@ -54,6 +54,7 @@
     decide,
     descriptions,
     enhance,
+    event_mutes,
     event_reactions,
     events,
     extensions,
@@ -3777,6 +3778,7 @@ def set_mail_routing(ctx: Context, account: int, rules: list[str], watch: int |
         max_length=20000,
     ),
     Arg("unreviewed", "boolean", "only those you haven't marked reviewed"),
+    Arg("hidden", "boolean", "true: only what you hid or muted; false: none of it (left out: what you hid shows, what you muted doesn't)"),
     Arg(
         "order",
         "string",
@@ -3798,6 +3800,7 @@ def timeline(
     q: str | None,
     where: str | None,
     unreviewed: bool | None,
+    hidden: bool | None,
     order: str | None,
     before: str | None,
     limit: int,
@@ -3806,9 +3809,8 @@ def timeline(
         ctx.acl, kinds, [actor] if actor else None, [namespace] if namespace else None, tag, since, until, q, where
     )
     who = activity_routes.viewer(ctx.db, ctx.user, ctx.acl)
-    return activity_routes.timeline(
-        ctx.db, ctx.cfg, who, flt, before, limit, {"reviewed": False} if unreviewed else None, order or "latest"
-    )
+    marked = {**({"reviewed": False} if unreviewed else {}), **({"hidden": hidden} if hidden is not None else {})}
+    return activity_routes.timeline(ctx.db, ctx.cfg, who, flt, before, limit, marked or None, order or "latest")
 
 
 @tool(
@@ -3834,6 +3836,45 @@ def mark_activities(
     return activity_routes.mark(ctx.db, ctx.cfg, who, ids, {"reviewed": reviewed, "important": important, "hidden": hidden})
 
 
+@tool(
+    "activity_mutes",
+    "Your mutes on the timeline",
+    "The sources, people and kinds of activity the timeline leaves out for the person you act for (docs/timeline.md, "
+    "Muting), each for good or until a time. Nobody else's timeline changes.",
+)
+def activity_mutes(ctx: Context) -> dict[str, Any]:
+    return {"mutes": event_mutes.of(ctx.db, ctx.user.id)}
+
+
+@tool(
+    "mute_activities",
+    "Mute a source or a kind",
+    "Mute a source or person (actor, by id) or a kind of activity (kind; the kinds under it count too) on the timeline "
+    "for the person you act for, for good or until a time (snooze it for a day), or lift the mute with on false. "
+    "Muting hides, it never deletes: the activities stay, still trigger automations and still show to everyone else, "
+    "and timeline with hidden true shows them. The answer is their mutes now. Needs a token with the write scope.",
+    Arg("actor", "string", "an actor's id, like lens:source/12 or lens:account/1", max_length=240),
+    Arg("kind", "string", "a kind, like sensor.reading", max_length=120),
+    Arg("name", "string", "the actor's name, for the Muted list on the page", max_length=200),
+    Arg("until", "string", "until this time (ISO 8601); left out: for good", max_length=40),
+    Arg("on", "boolean", "mute (true, the default) or lift the mute (false)"),
+    writes=True,
+)
+def mute_activities(
+    ctx: Context, actor: str | None, kind: str | None, name: str | None, until: str | None, on: bool | None
+) -> dict[str, Any]:
+    if not ctx.user.can_write:
+        raise ToolError("this token is read-only: ask for a token with the write scope to mute")
+    try:
+        if on is False:
+            mutes = event_mutes.unmute(ctx.db, ctx.user.id, actor, kind)
+        else:
+            mutes = event_mutes.mute(ctx.db, ctx.user.id, actor, kind, until, name)
+    except ValueError as e:
+        raise ToolError(str(e)) from None
+    return {"mutes": mutes}
+
+
 @tool(
     "react_to_activity",
     "React to an activity",