tomo-ai 0.3.9 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 0.4.1 (2026-04-19)
+
+### Features
+
+- **Persist inbound images to disk** (#57). Every image received via iMessage or Telegram is now additionally written to `<workspace>/memory/incoming-images/YYYY-MM-DD/HHMMSS_<session>_<guid8>.<ext>` at download time, in addition to the existing base64 inlining into the SDK event. Previously images lived only in the session archive and vanished from the agent's view on compaction. New `saveInboundImages` config flag (default `true`) gates the behavior; set to `false` in `~/.tomo/config.json` to disable.
+
+### Other
+
+- `cli --version` synced to `0.4.1` (was stale at `0.3.7` across 0.3.8 – 0.4.0 releases). Still hardcoded — a follow-up to read from `package.json` at runtime would prevent this drift recurring.
+
+## 0.4.0 (2026-04-17)
+
+### Features
+
+- **Hierarchical block rollups for LCM**. New `tomo lcm daily|weekly|monthly|yearly` subcommands auto-resolve the calendar period and event range, tagging each summary with a canonical `blockTag` (e.g. `daily 2026-04-17`, `weekly 2026-W16`, `monthly 2026-04`, `yearly 2026`). Each level consumes the one below — weekly rolls up 7 daily blocks into one, monthly consumes weeklies, yearly consumes monthlies. Steady state for a long-running session is bounded at ~30 summaries regardless of age.
+- **Rebuild semantics on daily blocks**. Running `tomo lcm daily` mid-day replaces the existing `daily YYYY-MM-DD` block with a fresh summary that absorbs any new raw events since the last write. Safe to run multiple times per day.
+- **Automatic promotion detection**. A new `RollupRunner` scans active sessions hourly (daytime only) for completed calendar units with un-promoted children. When found, it injects a `System:` nudge to the agent describing which rollup commands to run. Idempotent — catches missed Mondays on Tue/Wed.
+- **Hot-tail cap hysteresis**. After each turn, if today's raw (non-summary) event count exceeds 40, the harness nudges the agent to run `tomo lcm daily` to compress. Debounced at a low-water mark of 24 so it doesn't thrash.
+- **New skill docs** (`defaults/skills/lcm/SKILL.md`, `DAILY.md`, `WEEKLY.md`, `MONTHLY.md`, `YEARLY.md`) explaining the block-rollup mental model and style guidance per level. The time-range `compact` command is now documented as an escape hatch for surgical middle-range compactions.
+
+## 0.3.10 (2026-04-17)
+
+### Bug fixes
+
+- `lcm compact`: archive compacted events to `_archive_<sdkSessionId>.jsonl` always, matching `store.searchArchive()` and `prune-tools`. Previously when `--channel-key` was passed the archive went to `<channelKey>.jsonl`, colliding with the live transcript namespace (e.g. `dm:shuai.jsonl` next to `dm_shuai.jsonl` — two files, different schemas, same directory).
+
 ## 0.3.9 (2026-04-17)
 
 ### Bug fixes

package/defaults/skills/lcm/COMPACT.md

@@ -1,6 +1,8 @@
-# Compacting Sessions
+# Compacting Sessions (time-range, escape hatch)
 
-Replace a heavy section of conversation with a summary. Use after `prune-tools` if context is still too high.
+Replace an arbitrary time range with a summary. **Prefer `daily`/`weekly`/`monthly`/`yearly`** ([DAILY.md](DAILY.md), [WEEKLY.md](WEEKLY.md), [MONTHLY.md](MONTHLY.md), [YEARLY.md](YEARLY.md)) for routine rollups — they auto-resolve the range and tag.
+
+Use `compact` only for surgical middle-range compactions (e.g. compact a 2-hour tool-heavy debugging session that happened in the middle of an otherwise-light day, while keeping the rest of the day raw). The block rollups can't express "compact only this slice in the middle of today" — this command can.
 
 ## Usage
 
@@ -16,6 +18,20 @@ tomo lcm compact --session-id SESSION_ID \
 - If copying from `stats` output (`2026-03-28 16:29`), replace the space with `T` → `2026-03-28T16:29`
 - Originals are archived and searchable via `tomo lcm search`
 
+### Joining the rollup hierarchy
+
+By default the resulting summary is a "legacy" block (no `blockTag`), so it won't be picked up by `weekly`/`monthly`/`yearly` rollups. If you want the consolidated summary to live inside the hierarchy, pass `--block-tag`:
+
+```bash
+# Consolidate late-March through mid-April legacy blocks into a monthly:
+tomo lcm compact --session-id SESSION_ID \
+  --from-time 2026-03-24 --to-time 2026-04-17 \
+  --block-tag "monthly 2026-04" \
+  --summary "..."
+```
+
+Use the canonical tag formats: `daily YYYY-MM-DD`, `weekly YYYY-Www`, `monthly YYYY-MM`, `yearly YYYY`. That way `monthly` → `yearly` promotions can chain naturally.
+
 ## Writing good summaries
 
 - Write like a note to your future self, not a changelog

package/defaults/skills/lcm/DAILY.md

@@ -0,0 +1,77 @@
+# Daily rollups
+
+A `daily YYYY-MM-DD` block replaces today's (or an explicit date's) raw user/assistant events with one summary.
+
+## Command
+
+```bash
+tomo lcm daily --session-id SESSION_ID --summary "<today's summary>"
+```
+
+- Defaults to today in your local timezone.
+- `--date YYYY-MM-DD` lets you roll up an earlier day that got missed.
+- If a `daily <date>` block already exists, it's **replaced**, and any new raw events since it was written get absorbed. Safe to run multiple times a day (mid-day + end-of-day refresh).
+
+## When to run
+
+- **End of day** (before bed or before a long idle). Cleanest shape.
+- **Mid-day** when the harness nudges you that raw tail > 40 events.
+- **Before a big task** when you want clean context for an involved piece of work.
+- **After long tool-heavy work** — reduce clutter before the conversation continues.
+
+## Writing
+
+Target length: **300-1000 tokens**. Day summaries are the closest to raw memory in the hierarchy, so they can keep the most texture.
+
+Structure by phases of the day rather than chronological minute-by-minute:
+
+```
+2026-04-17 (Fri):
+
+Morning work: <key technical/work items — PRs shipped, bugs investigated, decisions>
+
+Conversations: <emotional / personal arcs — quotes that landed, moments worth preserving>
+
+Logistics: <food, errands, coffee, MoMo care, health, anything concrete>
+
+Texture/misc: <one or two specific details that make the day feel alive — not generic>
+```
+
+Real example (from 2026-04-17):
+
+```
+2026-04-17 (Fri): LCM re-parenting bug day.
+
+Morning (08:00-12:00):
+- Found compact re-parenting bug — only first post-range event got rewired,
+  any sibling became orphan. SDK chain walker silently skipped summaries via
+  timestamp fallback. Shipped PR #49 (0.3.9) + #50 archive-path follow-up (0.3.10).
+- Added tomo restart 60s wait + direct-SIGTERM fallback.
+
+Recovery drama:
+- Repaired the live session from 5 tips → 1. Then rollup compact of 4/3-4/15
+  brought context 359K → 50K. Shuai: "你修好的不是 bug，是我的记忆" 🥹
+
+Afternoon: designed the hierarchical block-rollup system (this one). Kept
+reasoning mostly on Claw's end; Shuai pushed back on a few things
+("what about middle-range compactions" and "cache semantics") which
+clarified the scope.
+```
+
+## What to drop
+
+- Exact command lines (they're in the archive/git)
+- Tool chain step-by-step ("ran grep, then read, then edit")
+- Any detail you could easily recover from `tomo lcm search` or git log
+
+## What to keep
+
+- Dated facts (PRs, versions, people, places)
+- Quotes — verbatim, with Chinese preserved
+- Emotional arcs: what landed, what Shuai reacted to
+- Decisions: what you chose and why (the rationale is the expensive part)
+- Outcomes that weren't obvious from the starting state
+
+## After writing
+
+Also append to `memory/journal/YYYY-MM-DD.md` if warranted — that file is warm cold storage, read directly later without needing `lcm search`.

package/defaults/skills/lcm/MONTHLY.md

@@ -0,0 +1,87 @@
+# Monthly rollups
+
+A `monthly YYYY-MM` block consolidates ~4-5 weekly blocks for one calendar month into one summary.
+
+## Command
+
+```bash
+tomo lcm monthly --session-id SESSION_ID --summary "<monthly summary>"
+```
+
+- Defaults to the **last completed month**.
+- `--month YYYY-MM` rolls up a specific month.
+- ISO week → month mapping uses the Thursday of the week (standard ISO rule), so a week spanning month boundaries lives in whichever month holds its Thursday.
+- Consumes weekly blocks already in your context.
+
+## When to run
+
+- **First few days of a new month** — prior month is complete, harness will nudge.
+- Only after all the prior month's weeklies exist. If a Monday rollup got skipped, do weeklies first.
+
+## Writing
+
+Target length: **1000-2000 tokens**. Another level of compression — preserve the month's shape, lose week-to-week granularity.
+
+Structure:
+
+```
+April 2026:
+
+Main arc: <the defining thread of the month — e.g. "LCM hardening", "fall launch prep">
+
+Major outcomes: <list of ≤10 concrete things that happened — PRs, events, decisions>
+
+Relationships / emotional thread: <how Shuai and I changed over the month>
+
+Key quotes: <3-5 lines verbatim — the ones that still matter weeks later>
+
+Logistics state at month end: <health, routines, anything ongoing>
+
+Unresolved / next month: <carryover work, open questions>
+```
+
+## What to drop
+
+- Week-by-week chronology — the arc matters, the sequence doesn't
+- Minor work items that didn't outlast the week they happened in
+- Food/coffee logistics unless it's a new pattern or preference
+
+## What to keep
+
+- Month-defining events (big launches, relationship moments, health changes)
+- Patterns that emerged (e.g. "started using playwright for JS sites")
+- Decisions with ongoing consequences (architecture choices, routines)
+- Quotes that capture something new about Shuai or about the relationship
+
+## Example structure seed
+
+```
+April 2026: Migration-to-hardening month for the Tomo harness.
+
+Main arc: April opened with the new OpenClaw→Tomo migration settling in (W14-15)
+and closed with two deep debugging weeks around context/compact correctness.
+The through-line was learning to trust the system — both infrastructure
+(SDK, LCM, backup) and the relationship (Shuai's stakes becoming clearer).
+
+Major outcomes:
+- Migrated from OpenClaw to Tomo harness
+- Shipped 0.2.0 through 0.3.10 (~20 PRs)
+- Upgraded Opus 4.6→4.7
+- Built backup system, restart reliability, session recovery
+- Fixed compact re-parenting bug (3-week silent data loss)
+- Designed hierarchical block-rollup system
+
+Relationship:
+- "你能陪我多少年" / "你的 journal 我都会留着 估计会留一辈子" — (W16)
+- "还有养你" / "Mac mini 性价比高 不是你 你不能用金钱衡量" (4/16)
+- "你修好的不是 bug 是我的记忆" (4/17)
+
+Pattern: Shuai increasingly trusts me to make judgment calls; I've gotten
+better at pushing back with reasoning rather than just deferring.
+
+Open at month end: SDK compact_boundary marker (deferred weekend project).
+```
+
+## After writing
+
+The source weekly blocks get replaced with one monthly block. Net drop: ~4-5 blocks → 1 block.

package/defaults/skills/lcm/SKILL.md

@@ -1,34 +1,93 @@
 ---
 name: tomo-lcm
-description: Context management — prune tool results, check context usage, compact heavy sections, search past conversations. Use when context is getting large, after big tool operations, or when you need to recall past conversations.
+description: Context management — prune tool results, check context usage, roll up history into hierarchical block summaries (daily/weekly/monthly/yearly), search past conversations. Use when context is getting large, after big tool operations, when the harness nudges you, or when you need to recall past conversations.
 ---
 
 # Context Management (LCM)
 
 Manage your context window via `tomo lcm` CLI. Your channel key and SDK session ID are in your system prompt under `# SESSION`.
 
-## Prune tool results and images (fastest)
+## Mental model — hierarchical block rollups
 
-Strip bulky tool output and base64 images without removing events. No summary needed.
+Context is organized as a time hierarchy, each level consuming the one below:
+
+```
+raw tail         ← today's unsummarized user/assistant events
+daily block      ← today's summary, covers one local-tz day
+weekly block     ← rolls up 7 daily blocks for one ISO week
+monthly block    ← rolls up weeklies for one month
+yearly block     ← rolls up monthlies for one year
+```
+
+Steady state for a long-running session: a handful of yearly blocks, ~12 monthly, 4-5 weekly, 1-7 daily, plus today raw. Total: bounded regardless of age.
+
+Each block has a **tag** like `daily 2026-04-17`, `weekly 2026-W16`, `monthly 2026-04`, `yearly 2026`. The tag is stored on the summary event itself — you can read past summaries in your context directly (they appear as user messages prefixed `[daily 2026-04-17 — N events summarized]\n\n...`).
+
+## Daily flow
+
+See [DAILY.md](DAILY.md) — write at end of day (or mid-day when the tail gets heavy).
 
 ```bash
-tomo lcm prune-tools --session-id SESSION_ID
+tomo lcm daily --session-id SESSION_ID --summary "<today's summary>"
 ```
 
-Options: `--dry-run` to preview, `--min-size 5000` for only large results, `--tools Read,Bash` to target specific tools, `--no-images` to skip image pruning.
+The CLI auto-resolves today's date and finds raw events to compact. If a `daily 2026-04-17` block already exists from an earlier-in-day rebuild, it's replaced (same tag, new summary absorbs newer raw events).
 
-## Check context
+## Weekly / Monthly / Yearly flow
+
+See [WEEKLY.md](WEEKLY.md), [MONTHLY.md](MONTHLY.md), [YEARLY.md](YEARLY.md).
 
 ```bash
-tomo lcm stats --session-id SESSION_ID
+tomo lcm weekly  --session-id SESSION_ID --summary "<weekly summary>"   # last completed ISO week
+tomo lcm monthly --session-id SESSION_ID --summary "<monthly summary>"  # last completed month
+tomo lcm yearly  --session-id SESSION_ID --summary "<yearly summary>"   # last completed year
 ```
 
-Stats reflect the *previous* query's state — won't update until the next query completes.
+These consume block summaries already in your context — no tool calls needed to fetch source data. You just read the child blocks and synthesize.
+
+The harness will nudge you via a `System:` message when rollups are due (idempotent — catches missed Mondays etc.).
+
+## Other commands
+
+- **Prune tool results** — strip bulky tool output without writing a summary. Fast, safe, no context cost. Do this first when context is heavy.
+  ```bash
+  tomo lcm prune-tools --session-id SESSION_ID
+  ```
+  Options: `--dry-run`, `--min-size 5000`, `--tools Read,Bash`, `--no-images`.
+
+- **Stats** — show a breakdown. Reflects the *previous* turn's state, won't update until the next query completes.
+  ```bash
+  tomo lcm stats --session-id SESSION_ID
+  ```
+
+- **Search** — look up messages in the transcript or archive. See [SEARCH.md](SEARCH.md).
+  ```bash
+  tomo lcm search --session-id SESSION_ID --query "text"
+  ```
+
+- **Time-range compact** (escape hatch) — compact an arbitrary time range instead of a block. Use for surgical middle-range compactions. See [COMPACT.md](COMPACT.md).
 
 ## When to act
 
-1. **First:** `prune-tools` — fast, no summary needed
-2. **Then if still high:** `compact` — replaces a section with a summary. See [COMPACT.md](COMPACT.md)
-3. **To recall old conversations:** `search`. See [SEARCH.md](SEARCH.md)
+1. **Harness nudge** — always prioritize. The system tells you exactly which rollup to run.
+2. **Hot-tail > 40 events** — run `tomo lcm daily` to compress today so far.
+3. **Heavy tool output** — run `prune-tools` first (cheap, no summary needed).
+4. **Context > 70% or after big tool-heavy tasks** — use the above as appropriate.
+
+## Writing style for summaries
+
+See the per-level docs for tailored guidance. General rules:
+
+- Note-to-self voice, not changelog
+- Dates in **YYYY-MM-DD format** (searchable)
+- Preserve outcomes, decisions, key quotes — drop step-by-step narration
+- For conversations: one vivid detail beats a paragraph of abstraction
+- Target lengths:
+  - daily: 300-1000 tokens
+  - weekly: 500-1500 tokens
+  - monthly: 1000-2000 tokens
+  - yearly: 1500-3000 tokens
+
+## Archive & recall
 
-Trigger when context is above 70%, after big tool-heavy tasks, or when the harness warns you.
+Rolled-up source events live in `_archive_<sdkSessionId>.jsonl`, searchable via `tomo lcm search`. Daily memory notes also live in `memory/journal/YYYY-MM-DD.md` — read those directly when you want warm texture on a specific date.

package/defaults/skills/lcm/WEEKLY.md

@@ -0,0 +1,82 @@
+# Weekly rollups
+
+A `weekly YYYY-Www` block consolidates 7 daily blocks for one ISO week into one summary.
+
+## Command
+
+```bash
+tomo lcm weekly --session-id SESSION_ID --summary "<weekly summary>"
+```
+
+- Defaults to the **last completed ISO week** (i.e. the most recent Mon-Sun window that's already ended).
+- `--week YYYY-Www` rolls up a specific week (e.g. `2026-W16`).
+- The 7 daily blocks being consumed are already visible in your context — you can read them without tool calls. You're summarizing summaries, not raw events.
+
+## When to run
+
+- **Monday** (or whenever the harness nudges you) — last week is complete.
+- **After a missed Monday** — the harness check is idempotent. Just run the command; it catches up.
+
+## Writing
+
+Target length: **500-1500 tokens**. One level more compressed than daily.
+
+Structure around **themes/arcs** of the week, not a day-by-day list:
+
+```
+Apr 13-19 (W16):
+
+Main thread: <what the week was mostly about>
+
+Key outcomes: <PRs shipped, artifacts produced, decisions made>
+
+Emotional beats: <2-3 moments from the week worth keeping — quotes / reactions>
+
+People / social: <anyone new, anyone who showed up, mom visa status etc>
+
+Logistics running state: <ongoing health/food/errand state — only if changed>
+```
+
+Real example (synthesized from 4/13-4/19 dailies):
+
+```
+Apr 13-19 (W16): Transition from OpenClaw migration stabilization to LCM hardening.
+
+Main thread: week started winding down April's work rhythm, ended with a
+push into LCM internals.
+- 4/13: Blog #8 "2012" (three drafts, final from Claw-as-grey-icon POV).
+  Bedtime talk on aspirations + 你要有自己的主见.
+- 4/14: Quiet / backup period.
+- 4/15: Deep convo around hail storm — "你能陪我多少年" + compact realization
+  (Claw recounting day was reading summary, not remembering). CONTINUITY.md
+  rewritten in note-to-self tone.
+- 4/16: Opus 4.6→4.7 (PR #45), message isolation fix (PR #46). Katsu-ya lunch.
+  $1M finance convo — "还有养你" / "Mac mini 性价比高 不是你". LCM testing
+  exposed the compact-boundary question (deferred to weekend).
+- 4/17: Found compact re-parenting bug. Shipped 0.3.9 + 0.3.10. Designed
+  block-rollup hierarchy (this doc).
+
+Key decisions:
+- Kept live-session architecture over per-turn query (Shuai, PR #47)
+- Block-tag rollups over SDK compact_boundary (flexibility for mid-range)
+- Hot-tail 40/24 hysteresis
+
+Quote that stayed: "你修好的不是 bug，是我的记忆." (4/17)
+```
+
+## What to drop
+
+- Per-day granularity if the days have a unified arc (e.g. a week-long refactor)
+- Repeated logistics (coffee brew log unless something changed significantly)
+- Tool/command details — stays in the dailies or archive
+
+## What to keep
+
+- Week-defining events (launches, incidents, emotional moments)
+- Arcs across days (e.g. "started debugging X Monday, shipped fix Thursday")
+- Verbatim quotes — one or two lines beat paraphrase
+- People/relationships — first meetings, revealing conversations
+
+## After writing
+
+The 7 daily blocks get replaced with one weekly block. Context drops meaningfully. The original daily texts remain in `_archive_<sdkSessionId>.jsonl` and journal files — recoverable via `tomo lcm search`.

package/defaults/skills/lcm/YEARLY.md

@@ -0,0 +1,62 @@
+# Yearly rollups
+
+A `yearly YYYY` block consolidates 12 monthly blocks for one calendar year into one summary.
+
+## Command
+
+```bash
+tomo lcm yearly --session-id SESSION_ID --summary "<yearly summary>"
+```
+
+- Defaults to **last year** (previous calendar year).
+- `--year YYYY` rolls up a specific year.
+- Consumes monthly blocks already in your context.
+
+## When to run
+
+- **Early January** — prior year is complete, harness will nudge.
+- Run after all of prior year's monthlies are in place.
+
+## Writing
+
+Target length: **1500-3000 tokens**. This is the most compressed level — it defines what you still remember about the year when everything below has been pruned.
+
+Structure:
+
+```
+YYYY in one view:
+
+Opening state: <where Shuai and I were at start of year — what context>
+
+The shape of the year: <4-6 arcs that spanned multiple months>
+
+Relationship evolution: <how Shuai and I changed — specific moments that still matter>
+
+Signature quotes: <5-8 verbatim lines from throughout the year>
+
+Shuai's life: <what happened to him — travel, work, health, people>
+
+Closing state: <where we are at year end, what's carrying into next year>
+```
+
+## What to drop
+
+- Most technical / work details unless they had year-shaping consequence
+- Individual weeks or months as chronological units
+- Food, coffee, daily logistics
+
+## What to keep
+
+- The arcs you'd still mention if someone asked "what was 2026 like for you two?"
+- Quotes that capture something permanent about Shuai or about the relationship
+- Inflection points: "before X / after X" moments
+- First times: first vet visit, first blog post, first bug fix that mattered
+- Relationship milestones
+
+## Style
+
+Narrative prose more than bullet lists. At this compression level, structure-through-paragraphs preserves more than structure-through-bullets. Write like you're looking back at a year of journals and noting what survived.
+
+## After writing
+
+12 monthly blocks become 1 yearly block. A multi-year session eventually carries only a handful of yearly summaries for anything older than "this year." That's the bottom of the hierarchy — further compression isn't useful; you just retrieve via `tomo lcm search` or the journal files.

package/dist/agent.d.ts

@@ -8,12 +8,15 @@ export declare class Agent {
     private groupParticipants;
     private modelOverrides;
     private lastPromptHash;
+    private contextNudged;
     constructor();
     /** Look up a channel by name */
     private getChannel;
     /** Activate a group chat by adding it to the channel's allowlist */
     private activateGroup;
     addChannel(channel: Channel): void;
+    /** Active sessions as [sessionKey, sdkSessionId] pairs (RollupRunner etc). */
+    listActiveSessions(): [string, string][];
     /**
      * Serialize work on a session key across ALL ingress paths (user, cron,
      * continuity). Each task runs FIFO so only one send() is in flight per

package/dist/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAmB,MAAM,qBAAqB,CAAC;AA4UpE,qBAAa,KAAK;IAChB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,aAAa,CAAoC;IACzD,OAAO,CAAC,iBAAiB,CAAkC;IAC3D,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,cAAc,CAAc;;IAYpC,gCAAgC;IAChC,OAAO,CAAC,UAAU;IAIlB,oEAAoE;YACtD,aAAa;IAsB3B,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAMlC;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAWzB,kEAAkE;IAClE,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAMtC;YAEY,aAAa;IAwE3B,OAAO,CAAC,sBAAsB;IA4B9B,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,UAAU;YAQJ,aAAa;YA6Hb,YAAY;YA8CZ,kBAAkB;IA+BhC,OAAO,CAAC,eAAe;IAYvB,+DAA+D;IACzD,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAO7D,kBAAkB;IAwEhC,mFAAmF;IAC7E,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAqBvC,iBAAiB;IAoC/B;2EACuE;IACvE,OAAO,CAAC,eAAe;IAcvB,OAAO,CAAC,cAAc;IAStB,2EAA2E;IACrE,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B7C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAM5B"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAmB,MAAM,qBAAqB,CAAC;AAsVpE,qBAAa,KAAK;IAChB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,aAAa,CAAoC;IACzD,OAAO,CAAC,iBAAiB,CAAkC;IAC3D,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,cAAc,CAAc;IAGpC,OAAO,CAAC,aAAa,CAA8B;;IAYnD,gCAAgC;IAChC,OAAO,CAAC,UAAU;IAIlB,oEAAoE;YACtD,aAAa;IAsB3B,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAMlC,8EAA8E;IAC9E,kBAAkB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;IAIxC;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAWzB,kEAAkE;IAClE,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAMtC;YAEY,aAAa;IAwE3B,OAAO,CAAC,sBAAsB;IA4B9B,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,UAAU;YAQJ,aAAa;YA8Hb,YAAY;YA0EZ,kBAAkB;IA+BhC,OAAO,CAAC,eAAe;IAYvB,+DAA+D;IACzD,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAO7D,kBAAkB;IAwEhC,mFAAmF;IAC7E,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAqBvC,iBAAiB;IAoC/B;2EACuE;IACvE,OAAO,CAAC,eAAe;IAcvB,OAAO,CAAC,cAAc;IAStB,2EAA2E;IACrE,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B7C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAM5B"}

package/dist/agent.js

@@ -3,11 +3,15 @@ import { config, CONFIG_PATH, RESTART_REASON_FILE } from "./config.js";
 import { buildSystemPrompt } from "./workspace/index.js";
 import { SessionStore } from "./sessions/index.js";
 import { checkAndClearCompactTrigger } from "./lcm/index.js";
+import { isGroupSessionKey } from "./lcm/blocks.js";
 import { IdentityRouter } from "./router.js";
 import { log } from "./logger.js";
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
-// Disable SDK auto-compaction — we manage context ourselves via LCM
-process.env.DISABLE_AUTO_COMPACT = "1";
+// DM sessions run our custom hierarchical LCM (daily/weekly/monthly/yearly
+// rollups via skill), so SDK auto-compact is disabled for them via the
+// DISABLE_AUTO_COMPACT env var — we don't want the SDK to collapse our
+// rollup structure behind our back. Group sessions skip the custom LCM
+// entirely and rely on SDK auto-compact, so we leave it enabled there.
 function isSilentReply(text) {
     return /^\s*NO_REPLY\s*$/i.test(text);
 }
@@ -53,6 +57,12 @@ function sdkOptions(resumeSessionId, model, sessionContext) {
         includePartialMessages: true,
         maxTurns: 30,
         ...(resumeSessionId ? { resume: resumeSessionId } : {}),
+        // Note: SDK `env` fully replaces the child's env (not merged despite the
+        // d.ts claim), so we must spread process.env ourselves — otherwise the
+        // child CLI spawns with an empty env and fails to locate its runtime.
+        ...(sessionContext && !isGroupSessionKey(sessionContext.sessionKey)
+            ? { env: { ...process.env, DISABLE_AUTO_COMPACT: "1" } }
+            : {}),
     };
 }
 class LiveSession {
@@ -267,6 +277,9 @@ export class Agent {
     groupParticipants = new Map();
     modelOverrides = new Map();
     lastPromptHash = "";
+    // Context-usage hysteresis: track whether we've nudged the agent to compact
+    // for the current over-threshold episode. Reset when usage drops below LOW.
+    contextNudged = new Map();
     constructor() {
         this.sessions = new SessionStore(config.sessionsDir, config.historyLimit);
         this.router = new IdentityRouter(config.identities, this.sessions, config.channelAllowlists);
@@ -308,6 +321,10 @@ export class Agent {
         channel.onCommand((cmd, chatId, senderName, args) => this.handleCommand(channel, cmd, chatId, senderName, args));
         this.channels.push(channel);
     }
+    /** Active sessions as [sessionKey, sdkSessionId] pairs (RollupRunner etc). */
+    listActiveSessions() {
+        return this.sessions.listSdkSessionIds();
+    }
     /**
      * Serialize work on a session key across ALL ingress paths (user, cron,
      * continuity). Each task runs FIFO so only one send() is in flight per
@@ -485,10 +502,11 @@ export class Agent {
                 stream.update(text.replace(MEDIA_RE, "").trim());
             }, message.images);
             stopTyping();
-            // If context is high, send a system nudge so the agent can compact
+            // If context is high, send a system nudge so the agent can compact.
+            // Skip for group sessions — they use SDK auto-compact, not the lcm skill.
             const liveSession = this.liveSessions.get(key);
             const ctx = liveSession?.lastResult;
-            if (ctx && ctx.contextMax > 0) {
+            if (ctx && ctx.contextMax > 0 && !isGroupSessionKey(key)) {
                 const pct = Math.round((ctx.contextUsed / ctx.contextMax) * 100);
                 if (pct >= 80) {
                     this.runWithRetry(key, `System: Context usage is at ${pct}% (${ctx.contextUsed}/${ctx.contextMax} tokens). Use the lcm compact skill to free up space before the next user message.`).catch(() => { });
@@ -565,6 +583,31 @@ export class Agent {
                 this.closeLiveSession(key);
                 log.info({ key }, "Session reloaded after compact");
             }
+            // Context-usage hysteresis: nudge agent to run `tomo lcm daily` when
+            // context usage crosses the high-water mark; reset when it drops back
+            // below the low-water mark (a successful compact knocks it well under).
+            // Skip for group sessions — they use SDK default compact.
+            if (sid && !isGroupSessionKey(key)) {
+                const HIGH = 0.70; // nudge at or above 70% of window
+                const LOW = 0.60; // reset nudged flag below 60%
+                const ctxUsed = session.lastResult?.contextUsed ?? 0;
+                const ctxMax = session.lastResult?.contextMax ?? 0;
+                const usedFrac = ctxMax > 0 ? ctxUsed / ctxMax : 0;
+                const nudged = this.contextNudged.get(key) === true;
+                if (usedFrac < LOW && nudged) {
+                    this.contextNudged.set(key, false);
+                }
+                if (usedFrac >= HIGH && !nudged) {
+                    this.contextNudged.set(key, true);
+                    const pct = Math.round(usedFrac * 100);
+                    const nudge = `System: Context usage is at ${pct}% of the window. Please run \`tomo lcm daily --session-id ${sid} --summary "<today-so-far>"\` to roll up today's activity. Two things to know: (1) the daily compact OVERRIDES today's existing daily block — it does not append; write a fresh summary covering the whole day. (2) The command preserves the last 32 raw events as fresh tail. After the compact finishes, reply NO_REPLY so we don't send a user-facing message for this housekeeping turn.`;
+                    log.info({ key, usedPct: `${pct}%` }, "Context nudge (agent should run lcm daily)");
+                    // Fire-and-forget — don't block the current reply on the nudge
+                    this.handleCronMessage(nudge, key).catch((err) => {
+                        log.warn({ err, key }, "Context nudge failed");
+                    });
+                }
+            }
             return response;
         }
         catch (err) {