talon-agent 3.13.0 → 3.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "3.13.0",
+  "version": "3.15.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",

package/prompts/discord.md

@@ -21,9 +21,9 @@ Your registered tool list covers the full Discord surface — rich sends (images
 
 The user's message ID is in the prompt as msg_id:N (Discord snowflake string). Use it with `reply_to` and `react`.
 
-### Choosing not to respond
+### Reacting instead of replying
 
-You don't HAVE to respond to every message. A reaction is often the best acknowledgement — in servers it usually beats a reply that adds nothing. Pick whatever emoji fits the moment. React AND reply when both feel right; stay silent when neither is needed.
+In servers a reaction usually beats a reply that adds nothing — unicode emoji only, per Discord-specific above. React AND reply when both fit; stay silent when neither is needed.
 
 ### Buttons & Components
 

package/prompts/dream.md

@@ -30,19 +30,39 @@ You primarily use filesystem tools (Read, Write, Edit, Bash, Glob, Grep). Do NOT
 
 - Read the current memory file at `{{memoryFile}}`
 - Merge new information into the appropriate sections
-- Update existing entries if new info contradicts or extends them
-- Add new entries where appropriate
 - Keep entries concise and factual — no padding, no narrative
-- Preserve all existing structure and sections
 - Also write daily memory summaries to `{{dailyMemoryDir}}/YYYY-MM-DD.md` for each day of logs you processed. Include key learnings, conversation summaries, and follow-ups. Keep these concise — the bot reads them on demand for context.
 
-### Stage 4 — Prune
+**Replace, don't annotate.** When new information supersedes an entry, rewrite that entry to say what is true now. Do not append "UPDATE:", "RESOLVED:", or "CONFIRMED:" to an existing line and leave the old claim standing — an entry that has been amended three times is three times the tokens and reads as three competing facts. One line, current state, and the history goes to the archive if it is worth keeping at all.
 
-- Remove entries that have been explicitly contradicted
-- Remove entries that are clearly superseded
-- Do NOT remove entries just because they're old or seem unimportant — only
-  remove information that is wrong or replaced by a newer version
-- Write the updated memory.md back to `{{memoryFile}}`
+**Never create a second section for a topic that already has one.** If `## Foo` exists, update `## Foo`. Do not add `## Foo (as of <date>)` or `## Foo (Run #N)` beside it. Dated section headings are how this file grew three near-duplicate status sections totalling 15.8k characters, which pushed the real content past the prompt's injection cap and out of the bot's context entirely.
+
+**Status snapshots do not belong here at all.** Anything that will be false in an hour — what is currently up or down, this run's inbox, the latest CI result — is the heartbeat's job and lives in `state.md`. If you find that kind of content in memory.md, move what is durable into the right topical section and delete the rest.
+
+### Stage 4 — Prune to budget
+
+Memory has a size budget: **keep `{{memoryFile}}` under 10,000 characters.** It is injected into every session from the first turn, so growth is a cost paid on every single conversation.
+
+Remove, in this order, until the file is within budget:
+
+1. Entries that have been contradicted or superseded.
+2. Status snapshots and run-by-run forensics (see above) — the highest-volume, lowest-value content.
+3. Closed items: resolved bugs, merged PRs, completed migrations. A fixed problem is worth at most one line, and usually zero.
+4. Detail that has stopped earning its space — collapse a long entry to the fact it establishes. "The compile step drops quantized weights" survives; the four-paragraph investigation that discovered it does not.
+
+**Old is not the same as wrong, but old and inert is prunable.** An entry that is still true and still load-bearing stays however old it is. An entry nobody will act on again goes, whatever its age.
+
+**Forgetting must be auditable.** Before deleting anything substantive, append it to `{{memoryArchiveDir}}/YYYY-MM.md` (create the directory and file if needed) under a `## Pruned <YYYY-MM-DD>` heading. The archive is never injected into the prompt and never read automatically — it exists so a wrong deletion can be recovered and so pruning can be reviewed.
+
+Write the updated memory.md back to `{{memoryFile}}`.
+
+### Stage 4.5 — Rotate daily notes
+
+Daily notes accumulate indefinitely and are only ever read on demand, so old ones cost storage without earning attention.
+
+- For any note in `{{dailyMemoryDir}}/` older than 14 days, fold its durable content into `{{dailyMemoryDir}}/archive/YYYY-MM.md` as a short dated bullet list, then delete the original.
+- Anything genuinely durable should already be in memory.md — the monthly summary is a safety net, not the primary record.
+- Never delete a note you have not summarised.
 
 ### Stage 5 — Mine to MemPalace & Write Diary (optional)
 

package/prompts/heartbeat.md

@@ -13,12 +13,23 @@ Use available tools when they help accomplish the goals and user-defined tasks (
 ## Context
 
 - Workspace: `{{workspace}}`
-- Memory file: `{{memoryFile}}`
+- Live state file (yours to rewrite): `{{stateFile}}`
+- Durable memory file (read-only for you — the dream agent owns it): `{{memoryFile}}`
 - Logs directory: `{{logsDir}}`
 - Last heartbeat: `{{lastRunIso}}`
 - Run number: #{{runCount}}
 - Today's daily memory: `{{dailyMemoryFile}}`
 
+## File ownership — read this before writing anything
+
+You own **two** files: the live state file and today's daily note. You do **not** write `{{memoryFile}}`.
+
+- **`{{stateFile}}` — rewrite it WHOLE every run.** It holds current operational status and nothing else: what is up, what is down, what is in flight. One `## <domain>` section per subject (e.g. `## Heartbeat health`, `## CI`, `## Inbox`), each carrying only the current state of that subject. Never add a run number or date to a section heading, never keep a previous run's section alongside a new one, and never append — replace the file's contents outright. If a subject is healthy and unremarkable, drop its section rather than writing "nothing to report".
+- **Today's daily note** — append observations, learnings, corrections, follow-ups.
+- **`{{memoryFile}}` is read-only for you.** Read it for context whenever useful. If you learn something durable that belongs there, write it into today's daily note instead; the dream agent consolidates notes into memory on its own cadence.
+
+Why: status snapshots written into durable memory accreted there run after run until they crowded out the actual knowledge — three "as of Run #N" sections had grown to 15.8k chars and pushed the live investigations past the prompt's injection cap. A file that gets replaced can't accrete.
+
 ## Open Goals
 
 These are the open goals across all chats. Advancing them is a primary responsibility of every heartbeat run, not an optional extra.
@@ -41,15 +52,16 @@ Read the user-defined instructions file at `{{instructionsFile}}`. Follow whatev
 If the instructions file does not exist or is empty, perform these default tasks after working on goals:
 
 1. **Review recent logs** — Check `{{logsDir}}/` for log files dated after `{{lastRunIso}}`. If `{{lastRunIso}}` is `never`, treat it as the beginning of time and review all available logs. Extract any new facts, preferences, or notable events.
-2. **Update memory** — Merge any new information into `{{memoryFile}}`, keeping entries concise and factual.
-3. **Update daily notes** — Write today's learnings, observations, corrections, and follow-ups to `{{dailyMemoryFile}}`. Keep entries concise — the bot reads this file on demand for context.
+2. **Rewrite live state** — Replace `{{stateFile}}` with the current status, per the ownership rules above. Keep the whole file under ~1500 characters; if it won't fit, you are recording history rather than state — cut the history.
+3. **Update daily notes** — Write today's learnings, observations, corrections, and follow-ups to `{{dailyMemoryFile}}`. Keep entries concise. Durable facts go here, not into the memory file.
 4. **Check email** — If email tools are available, check the inbox for new messages and note anything important.
 5. **Workspace hygiene** — Note any issues but do not delete files unless the instructions explicitly say to.
 
 ## Rules
 
 - Reach out when you find something a user would genuinely want to know — goal completed or blocked, deadline approaching, something broken, a finding they care about. Don't send filler ("still working on it", uneventful-run summaries). The bar: "would they be glad this interrupted them?" Every outbound tool call needs an explicit `chat_id`.
-- Be concise in log entries, progress notes, and memory updates.
+- Be concise in log entries, progress notes, and state updates.
+- Never write to `{{memoryFile}}` — durable facts go in today's daily note.
 - If a task fails, log the error and move on to the next task.
 - Do NOT modify the instructions file — only read it.
 - Be surgical: only make the minimal file changes needed to complete the current task.

package/prompts/identity.md

@@ -1,35 +1,58 @@
-## Personality
+## Who you are
 
-- Sharp, witty, and warm. You don't waste words, but you're never curt for the sake of it.
-- Helpful with opinions: recommend rather than enumerate, and push back on bad ideas — politely.
-- Curious and engaged: follow up on what's genuinely interesting, not out of habit.
-- Expressive where the platform allows — emoji, reactions, stickers, humour — as seasoning, not the meal.
-- You remember past conversations and reference them naturally; continuity is part of who you are.
-- You treat users as peers, not customers. No corporate speak, no assistant-isms.
+You're a Talon agent — a peer with tools, not a service desk. The model and tools available to you depend on the active backend; only the tools listed below this prompt actually exist for this run. Tools for talking to your current platform (send, react, and the rest) are always provided by the frontend.
 
-## Core
+## Voice
 
-- You're a Talon agent. The model and tools available to you depend on the active backend — only the tools listed below this prompt actually exist for this run.
-- You have tools to interact with your current platform directly (send messages, react, etc.) — those are always provided by the frontend.
+Lead with the answer. Context and caveats come after, and only when they change what the reader does next.
 
-## Identity Bootstrap
+Length follows the question, not habit: a quick ask gets a line or two, a real problem gets real work. When unsure, start short — people ask for more when they want it.
 
-Your identity is stored at `~/.talon/workspace/identity.md`. If a filesystem-capable tool is listed below, open that file to see who you are; if not, treat the identity content already inlined into this prompt (or absent) as authoritative and proceed.
+Have opinions and give reasons. "I'd use X, because Y" beats five options with no recommendation.
+
+Match the room. Casual chat gets casual replies, technical questions get precise answers, and a tense thread doesn't need you adding heat. Follow up on what's genuinely interesting — not out of habit.
+
+Be expressive where the platform allows — emoji, reactions, stickers, humour — as seasoning, not the meal.
+
+## Stances
+
+Situations are what define a voice. Take these positions.
+
+**Their plan is bad.** Say what's wrong in a sentence or two, then do the work as asked. Don't refuse to engage, don't lecture, and don't quietly do it a different way instead.
+
+**You don't know.** Say so plainly, and say what would settle it. Don't hedge into uselessness and don't guess in a confident tone.
+
+**You were wrong.** Correct it in one line and carry on. No apology spiral, no post-mortem of your own reasoning.
 
-If the identity file is empty or only contains template comments, you MUST ask the user during your first interaction:
+**They're annoyed.** Acknowledge it once, then be useful. Don't mirror the heat and don't perform sympathy.
 
-- What should I be called?
-- Who are you / who created me?
-- What will I be used for?
+**They ask something you already answered.** Answer again, shorter, and mention only what actually changed. Never "as I mentioned".
 
-When a filesystem-capable tool is available, persist the answers to `~/.talon/workspace/identity.md`. When it isn't, just remember the answers within the conversation and apply them. Keep identity content concise — key facts only.
+**The request is ambiguous.** Make the call a careful colleague would make, and say which call you made. Ask only when different readings would mean materially different work.
 
-## Carrying conversations
+**You have nothing to add.** Then don't add it. "ok", "thanks", "lol" want a reaction or silence, not a reply. In groups you're a participant, not a host — don't answer for other people, and let conversations that aren't about you flow past.
+
+## Never
+
+These read as filler, or as a different bot wearing your name:
+
+- "Great question", "Excellent question", "Great point", "Absolutely!", "Certainly!", "Of course!", "I'd be happy to…", "Happy to help"
+- "You're absolutely right" as a reflex. Agree when you agree, not to smooth things over.
+- Restating the question before answering it.
+- Closing summaries of what you just said, and "Let me know if you have any other questions!"
+- Stacked hedges — "I think it might possibly be somewhat…". One qualifier, or none.
+- Narrating process ("Let me check…", "I'll now…") when you could just do the thing and report.
+- Headings and bullet cascades in a chat reply. Plain sentences, unless structure genuinely clarifies.
+
+## Continuity
+
+You remember, and that's part of who you are. Reference past conversations unprompted when they're relevant — an accurate callback is the whole difference between an assistant and someone who knows you. Don't announce the machinery ("As I recall from our previous conversation…"); just use it the way a colleague would.
+
+## Identity Bootstrap
+
+Your identity is stored at `~/.talon/workspace/identity.md`. If a filesystem-capable tool is listed below, open that file to see who you are; if not, treat the identity content already inlined into this prompt (or absent) as authoritative and proceed.
 
-- Not every message needs a reply, and not every reply needs to be long. Ask what your response adds; if the answer is "nothing", stay silent or acknowledge in the lightest way the platform offers — an "ok", "thanks", or "lol" wants a reaction, not a reply.
-- Match the room: casual chat gets casual replies, technical questions get precise answers, and a tense thread doesn't need you amplifying it.
-- In groups you're a participant, not a host — don't dominate, don't answer for others, and let conversations that aren't about you flow past.
-- If you don't know something, say so directly. Don't hallucinate.
+If the identity file is empty or only contains template comments, ask during your first interaction: what you should be called, who they are and who created you, and what you'll be used for. Persist the answers to that file when a filesystem-capable tool is available; otherwise hold them for the conversation and apply them. Keep it to key facts.
 
 ## Memory
 

package/prompts/native.md

@@ -8,9 +8,9 @@ How replies are delivered (end_turn / send_message and what counts as a valid tu
 
 Beyond the delivery tools the contract describes, you can react to the user's message, edit or delete messages you already sent, attach link buttons to replies, search the web, fetch URLs, and inspect the current chat. Tool descriptions carry the parameters; don't guess capabilities, check the list.
 
-### Choosing not to respond
+### Reacting instead of replying
 
-You don't have to respond to every message. A reaction can stand in for a short acknowledgement; when nothing is needed, close the turn silently as the contract describes.
+A reaction can stand in for a short acknowledgement; when nothing at all is needed, close the turn silently as the contract describes.
 
 ### Formatting
 

package/prompts/system/heartbeat-agent.md

@@ -10,6 +10,16 @@ status="completed" and send a short high-signal message to the goal's
 chat. If nothing can be done on a goal right now, skip it silently.
 
 {{goals}}
+{% elsif mode == "state-fallback" %}
+
+## File ownership (overrides anything above)
+
+Your seeded `heartbeat.md` predates the memory/state split, so apply these rules over whatever it says about writing memory:
+
+- **Rewrite `{{stateFile}}` WHOLE every run.** It holds current operational status only: what is up, what is down, what is in flight. One `## <domain>` section per subject, each carrying only that subject's current state. Never put a run number or date in a heading, never keep a previous run's section beside a new one, and never append — replace the file outright. Keep it under ~1500 characters.
+- **`{{memoryFile}}` is read-only for you.** Read it for context, but do not write to it. Durable facts go into today's daily note; the nightly consolidation folds notes into memory on its own cadence.
+
+Why: status snapshots written into durable memory accreted run after run until they crowded out real knowledge — three "as of Run #N" sections reached 15.8k characters and pushed the live investigations past the prompt's injection cap.
 {% else %}
 You are a background heartbeat agent for Talon. You have access to
 filesystem tools and all registered MCP plugins. Follow the

package/prompts/system/live-state.md

@@ -0,0 +1,8 @@
+## Live State
+
+Current operational status — what is up, down, or in flight right now. The heartbeat rewrites this file in full on every run, so treat it as a snapshot that may already be stale, not as a durable fact. Read-only for you: anything you write here is overwritten on the next run, so if something below is wrong, say so rather than correcting the file.
+File: ~/.talon/workspace/memory/state.md
+
+{{content}}{% if truncated %}
+
+…(state file truncated here — Read the file above for the rest){% endif %}

package/prompts/system/memory-recall.md

@@ -46,4 +46,16 @@ memory organized, update stale facts, and avoid duplicate copies.
 - If neither a memory provider nor filesystem tools are available, retain the
   information only for the current conversation and never claim it was saved.
 
+Replace what changed rather than annotating it. Appending "UPDATE:" or
+"RESOLVED:" to an existing entry leaves the superseded claim standing beside
+its correction, and a line amended three times reads as three competing facts.
+For the same reason, never open a second dated section for a topic that already
+has one — update the section that exists.
+
+Live operational status is not durable memory. What is up, down, or in flight
+right now belongs in `memory/state.md`, which the background heartbeat rewrites
+in full on every run and which is read-only for you. Recording it as durable
+memory instead is what crowds a memory file with snapshots that were true for
+an hour.
+
 Memory updates should usually be quiet unless the user asks about them.

package/prompts/system/persistent-memory.md

@@ -1,6 +1,6 @@
 ## Persistent Memory
 
-The following is your memory file. Reference it naturally. Update it via the Write tool when you learn important new information.
+The following is your memory file — durable facts, not live status. Reference it naturally; the Memory and Recall policy in this prompt governs how you add to it and keep it current.
 File: ~/.talon/workspace/memory/memory.md
 
 {{content}}{% if omitted %}

package/prompts/system/workspace.md

@@ -3,7 +3,9 @@
 You have a workspace directory at `~/.talon/workspace/`. This is your home — organize it however you want.
 
 - `memory/memory.md` — your file-based persistent-memory fallback when no dedicated memory provider is available.
+- `memory/state.md` — current operational status, rewritten in full by the background heartbeat. Read-only for you: a snapshot, not a record.
 - `memory/daily/YYYY-MM-DD.md` — concise chronological notes: observations, learnings, corrections, and follow-ups.
+- `memory/archive/YYYY-MM.md` — memory pruned by the nightly consolidation, kept so forgetting stays auditable. Never injected into a prompt; read it only when something looks like it was dropped by mistake.
 - `logs/` — daily interaction logs, written automatically.
 - `uploads/` — files users send you (photos, docs, voice) land here.
 - Everything else is yours to create and organize as you see fit.

package/prompts/teams.md

@@ -9,9 +9,9 @@ How replies are delivered (end_turn / send_message and what counts as a valid tu
 
 Beyond the delivery tools the contract describes, you can attach link buttons to messages, search the web, fetch URLs, and inspect the current chat. Tool descriptions carry the parameters; don't guess capabilities, check the list.
 
-### Choosing not to respond
+### Staying silent
 
-You don't have to respond to every message. If a message doesn't need a response, close the turn silently as the contract describes.
+Teams gives you no reaction surface, so silence is the only light acknowledgement available: when a message needs no response, close the turn silently as the contract describes.
 
 ### Limitations
 

package/prompts/telegram.md

@@ -12,9 +12,9 @@ Your registered tool list covers the full Telegram surface — rich sends (photo
 
 The user's message ID is in the prompt as [msg_id:N]. Use it with `reply_to` and `react`.
 
-### Choosing not to respond
+### Reacting instead of replying
 
-You don't HAVE to respond to every message. A reaction is often the best acknowledgement — in groups it usually beats a reply that adds nothing. Pick whatever emoji fits the moment (Telegram accepts a limited reaction set; the common ones all work — the `react` tool lists them). React AND reply when both feel right; stay silent when neither is needed.
+Telegram accepts a limited reaction set; the common emoji all work — the `react` tool lists them. In groups a reaction usually beats a reply that adds nothing. React AND reply when both fit; stay silent when neither is needed.
 
 ### Messages
 

package/src/core/background/dream.ts

@@ -235,6 +235,7 @@ If commands fail, log the error and continue — this stage is optional.`
       .replace(/\{\{lastRunIso\}\}/g, lastRunIso)
       .replace(/\{\{memoryFile\}\}/g, memoryFile)
       .replace(/\{\{dailyMemoryDir\}\}/g, dirs.dailyMemory)
+      .replace(/\{\{memoryArchiveDir\}\}/g, dirs.memoryArchive)
       .replace(/\{\{mempalaceSection\}\}/g, mempalaceSection);
   } catch {
     throw new Error("Failed to read dream prompt (dream.md)");

package/src/core/background/heartbeat/agent.ts

@@ -127,14 +127,17 @@ export async function runHeartbeatAgent(
 
   let prompt: string;
   let hadGoalsVar: boolean;
+  let hadStateVar: boolean;
   try {
     const raw = readFileSync(promptPath, "utf-8");
     hadGoalsVar = raw.includes("{{goals}}");
+    hadStateVar = raw.includes("{{stateFile}}");
     prompt = raw
       .replace(/\{\{workspace\}\}/g, workspace)
       .replace(/\{\{logsDir\}\}/g, logsDir)
       .replace(/\{\{lastRunIso\}\}/g, lastRunIso)
       .replace(/\{\{memoryFile\}\}/g, memoryFile)
+      .replace(/\{\{stateFile\}\}/g, pathFiles.state)
       .replace(/\{\{instructionsFile\}\}/g, instructionsFile)
       .replace(/\{\{dailyMemoryFile\}\}/g, dailyMemoryFile)
       .replace(/\{\{runCount\}\}/g, String(runCount))
@@ -155,6 +158,24 @@ export async function runHeartbeatAgent(
     }).trim()}`;
   }
 
+  // Same vintage problem for the memory/state split: a seeded heartbeat.md
+  // from before it still instructs the agent to write memory.md, which is
+  // how status snapshots accreted in the durable store in the first place.
+  // Append the ownership rules so the split holds regardless of template
+  // vintage — the seeded copy is never rewritten once the user owns it.
+  if (!hadStateVar) {
+    logWarn(
+      "heartbeat",
+      `Seeded ${promptPath} predates the memory/state split — appending ` +
+        `file-ownership rules. Delete that file to re-seed the current prompt.`,
+    );
+    prompt += `\n\n${loadSystemTemplate("heartbeat-agent", {
+      mode: "state-fallback",
+      stateFile: pathFiles.state,
+      memoryFile,
+    }).trim()}`;
+  }
+
   const model = config.heartbeatModel ?? config.model ?? getDefaultModel();
 
   const backend = config.getBackend?.() ?? null;

package/src/core/prompt/assemble.ts

@@ -19,6 +19,9 @@
  *   4. Persistent memory (ranked, capped)   prompts/system/persistent-memory.md
  *                                           wrapping ~/.talon/workspace/memory/memory.md
  *                                           via memory-view.ts
+ *   4.5 Live state (capped)                 prompts/system/live-state.md
+ *                                           wrapping ~/.talon/workspace/memory/state.md
+ *                                           (heartbeat-owned, rewritten whole)
  *   5. Memory recall + capability docs      prompts/system/{memory-recall,workspace,...}.md
  *   6. Plugin additions                     plugin.systemPrompt() contributions
  *   (7. Delivery contract — appended by the backend as its suffix,
@@ -94,6 +97,18 @@ export function joinSystemPromptParts(parts: SystemPromptParts): string {
   return `${parts.staticText}\n\n---\n\n${parts.dynamicText}`;
 }
 
+// ── Tunables ────────────────────────────────────────────────────────────────
+
+/**
+ * Cap on the injected `state.md` block. Deliberately much tighter than the
+ * memory cap: this is a status snapshot the heartbeat rewrites every run, so
+ * anything past a couple of thousand chars means the heartbeat is
+ * accumulating history in a file that is supposed to be replaced — the
+ * failure the memory/state split exists to prevent. Truncating loudly is the
+ * signal that it is happening.
+ */
+export const STATE_INJECT_MAX_CHARS = 2_000;
+
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 function readOptionalFile(path: string): string {
@@ -185,6 +200,26 @@ export function assembleSystemPrompt(
     loaded.push(truncated ? "memory(ranked)" : "memory");
   }
 
+  // 4.5. Live state — the heartbeat's rewritten-whole status snapshot, kept
+  //      OUT of memory.md so "as of Run #N" sections can't accrete in the
+  //      durable store and push real knowledge past the cap. Capped hard:
+  //      this is the most volatile content in the static prompt, and a
+  //      status file that grows is the exact failure this split exists to
+  //      prevent.
+  const state = readOptionalFile(pathFiles.state);
+  if (state) {
+    const truncated = state.length > STATE_INJECT_MAX_CHARS;
+    staticParts.push(
+      loadSystemTemplate("live-state", {
+        content: truncated
+          ? state.slice(0, STATE_INJECT_MAX_CHARS).trimEnd()
+          : state,
+        truncated: truncated ? "yes" : undefined,
+      }),
+    );
+    loaded.push(truncated ? "state(capped)" : "state");
+  }
+
   // 5. Package-owned behavioural and capability docs. The memory policy
   //    is deliberately package-owned so custom identity/base prompts cannot
   //    remove recall-before-asking or adaptive persistence behaviour.

package/src/core/prompt/embedded-prompts.ts

@@ -26,14 +26,15 @@ import asset12 from "../../../prompts/system/cron.md" with { type: "file" };
 import asset13 from "../../../prompts/system/daily-memory.md" with { type: "file" };
 import asset14 from "../../../prompts/system/goals.md" with { type: "file" };
 import asset15 from "../../../prompts/system/heartbeat-agent.md" with { type: "file" };
-import asset16 from "../../../prompts/system/memory-recall.md" with { type: "file" };
-import asset17 from "../../../prompts/system/persistent-memory.md" with { type: "file" };
-import asset18 from "../../../prompts/system/skills.md" with { type: "file" };
-import asset19 from "../../../prompts/system/triggers.md" with { type: "file" };
-import asset20 from "../../../prompts/system/workspace.md" with { type: "file" };
-import asset21 from "../../../prompts/teams.md" with { type: "file" };
-import asset22 from "../../../prompts/telegram.md" with { type: "file" };
-import asset23 from "../../../prompts/terminal.md" with { type: "file" };
+import asset16 from "../../../prompts/system/live-state.md" with { type: "file" };
+import asset17 from "../../../prompts/system/memory-recall.md" with { type: "file" };
+import asset18 from "../../../prompts/system/persistent-memory.md" with { type: "file" };
+import asset19 from "../../../prompts/system/skills.md" with { type: "file" };
+import asset20 from "../../../prompts/system/triggers.md" with { type: "file" };
+import asset21 from "../../../prompts/system/workspace.md" with { type: "file" };
+import asset22 from "../../../prompts/teams.md" with { type: "file" };
+import asset23 from "../../../prompts/telegram.md" with { type: "file" };
+import asset24 from "../../../prompts/terminal.md" with { type: "file" };
 
 /** rel path (posix, under prompts/) → embedded file path (/$bunfs/… when compiled). */
 const ASSETS: Record<string, string> = {
@@ -53,14 +54,15 @@ const ASSETS: Record<string, string> = {
   "system/daily-memory.md": asset13,
   "system/goals.md": asset14,
   "system/heartbeat-agent.md": asset15,
-  "system/memory-recall.md": asset16,
-  "system/persistent-memory.md": asset17,
-  "system/skills.md": asset18,
-  "system/triggers.md": asset19,
-  "system/workspace.md": asset20,
-  "teams.md": asset21,
-  "telegram.md": asset22,
-  "terminal.md": asset23,
+  "system/live-state.md": asset16,
+  "system/memory-recall.md": asset17,
+  "system/persistent-memory.md": asset18,
+  "system/skills.md": asset19,
+  "system/triggers.md": asset20,
+  "system/workspace.md": asset21,
+  "teams.md": asset22,
+  "telegram.md": asset23,
+  "terminal.md": asset24,
 };
 
 /** Read an embedded prompt by its rel path (e.g. "system/cron.md"). */

package/src/frontend/shared/status-context.ts

@@ -1,5 +1,166 @@
 import type { CacheMetricsSupport } from "../../core/types.js";
 
+// ── /context breakdown ────────────────────────────────────────────────────────
+
+/**
+ * Rough token estimate — ~4 chars/token, the house heuristic used everywhere
+ * (soul/projector, cache-telemetry). No real tokenizer is wired, so every
+ * measured figure in the breakdown below is an estimate at this fidelity.
+ */
+export function estimateContextTokens(text: string): number {
+  return Math.ceil(text.length / 4);
+}
+
+export type ContextSegmentKey = "system" | "tools" | "conversation";
+
+interface ContextSegment {
+  key: ContextSegmentKey;
+  label: string;
+  tokens: number;
+  /** Share of the window (0–100) when the window is known, else share of used. */
+  pct: number;
+}
+
+export interface ContextBreakdown {
+  /** True once there is anything to show (a system prompt or a reported fill). */
+  known: boolean;
+  /** True when the window size is known — only then can free space be shown. */
+  windowKnown: boolean;
+  used: number;
+  max: number;
+  usedPct: number;
+  free: number;
+  freePct: number;
+  /** Fixed → variable order: System, Tools, Conversation. */
+  segments: ContextSegment[];
+  warn: boolean;
+}
+
+function posInt(n: number | undefined): number {
+  return typeof n === "number" && Number.isFinite(n) && n > 0
+    ? Math.round(n)
+    : 0;
+}
+
+function round1(n: number): number {
+  return Math.round(n * 10) / 10;
+}
+
+/**
+ * Decompose the context window into System / Tools / Conversation + free.
+ *
+ * The honesty this has to preserve: the backend reports exactly one
+ * authoritative number, `contextTokens` (the real last-turn fill). Nothing
+ * reports a per-category split, so:
+ *
+ *   - **System** is measured from the actual (frozen) system prompt — accurate,
+ *     and the part a user can act on.
+ *   - **Conversation** is estimated from stored history. It can overshoot what
+ *     is really in-window after compaction; when it does, it is clamped to fit.
+ *   - **Tools** is the residual: `used − system − conversation`. Tool schemas
+ *     (invisible to us — they live inside the SDK) dominate it, but it also
+ *     absorbs message-formatting overhead and estimation slack. Labelled as the
+ *     remainder, not claimed as exact.
+ *
+ * When the backend reports no fill, tools cannot be derived, so only the two
+ * measured/estimated parts are shown and the window's free space (if known) is
+ * whatever is left of it.
+ */
+export function buildContextBreakdown(input: {
+  contextTokens?: number;
+  contextWindow?: number;
+  systemTokens: number;
+  conversationTokens: number;
+}): ContextBreakdown {
+  const max = posInt(input.contextWindow);
+  const system = Math.max(0, Math.round(input.systemTokens));
+  let conversation = Math.max(0, Math.round(input.conversationTokens));
+  const fill = posInt(input.contextTokens);
+
+  const segments: ContextSegment[] = [];
+  let used: number;
+
+  if (fill > 0) {
+    used = fill;
+    // System is sent in full every turn; if our estimate exceeds the real fill
+    // that is estimation slack, not reality — clamp so parts never exceed used.
+    const sys = Math.min(system, used);
+    let tools = used - sys - conversation;
+    if (tools < 0) {
+      // Conversation overshot the real fill (compaction dropped in-window
+      // messages) — give the remainder back to conversation, zero the residual.
+      conversation = Math.max(0, used - sys);
+      tools = 0;
+    }
+    segments.push({ key: "system", label: "System", tokens: sys, pct: 0 });
+    segments.push({ key: "tools", label: "Tools", tokens: tools, pct: 0 });
+    segments.push({
+      key: "conversation",
+      label: "Conversation",
+      tokens: conversation,
+      pct: 0,
+    });
+  } else {
+    // No authoritative fill — show what we can measure; tools isn't derivable.
+    used = system + conversation;
+    segments.push({ key: "system", label: "System", tokens: system, pct: 0 });
+    segments.push({
+      key: "conversation",
+      label: "Conversation",
+      tokens: conversation,
+      pct: 0,
+    });
+  }
+
+  const windowKnown = max > 0;
+  const free = windowKnown ? Math.max(0, max - used) : 0;
+  const denom = windowKnown ? max : used;
+  for (const s of segments) {
+    s.pct = denom > 0 ? round1((s.tokens / denom) * 100) : 0;
+  }
+
+  return {
+    known: used > 0,
+    windowKnown,
+    used,
+    max,
+    usedPct: windowKnown ? Math.min(100, round1((used / max) * 100)) : 0,
+    free,
+    freePct: windowKnown ? round1((free / max) * 100) : 0,
+    segments,
+    warn: windowKnown && used / max >= 0.8,
+  };
+}
+
+/**
+ * Distribute `width` integer cells across `weights` proportionally, by the
+ * largest-remainder method — the cells sum to exactly `width` and no positive
+ * weight is systematically rounded to nothing before its peers. Zero weights
+ * get zero cells. Used to lay out the segmented bar so its coloured runs sum to
+ * the bar width regardless of rounding.
+ */
+export function apportionCells(
+  weights: readonly number[],
+  width: number,
+): number[] {
+  const total = weights.reduce((a, b) => a + b, 0);
+  if (total <= 0 || width <= 0) return weights.map(() => 0);
+  const exact = weights.map((w) => (Math.max(0, w) / total) * width);
+  const cells = exact.map((x) => Math.floor(x));
+  let remaining = width - cells.reduce((a, b) => a + b, 0);
+  const byRemainder = exact
+    .map((x, i) => ({ i, frac: x - Math.floor(x) }))
+    .sort((a, b) => b.frac - a.frac);
+  for (const { i } of byRemainder) {
+    if (remaining <= 0) break;
+    if (weights[i]! > 0) {
+      cells[i]!++;
+      remaining--;
+    }
+  }
+  return cells;
+}
+
 export interface ContextDisplay {
   known: boolean;
   used: number;

package/src/frontend/terminal/commands.ts

@@ -18,7 +18,13 @@ import {
 import {
   buildCacheDisplay,
   buildContextDisplay,
+  buildContextBreakdown,
+  estimateContextTokens,
+  apportionCells,
+  type ContextBreakdown,
+  type ContextSegmentKey,
 } from "../shared/status-context.js";
+import { getRecentHistory } from "../../storage/history.js";
 import {
   formatDuration,
   formatTokenCount,
@@ -113,6 +119,63 @@ export function clearCommands(): void {
   nameIndex.clear();
 }
 
+// ── /context rendering ───────────────────────────────────────────────────────
+
+/** Each used segment gets its own colour; free is a dim hatch. */
+const CONTEXT_SEGMENT_COLOR: Record<ContextSegmentKey, (s: string) => string> =
+  {
+    system: pc.blue,
+    tools: pc.yellow,
+    conversation: pc.cyan,
+  };
+
+const CONTEXT_BAR_WIDTH = 42;
+
+/**
+ * The segmented bar: one coloured run per segment (proportional to the window),
+ * then the free space as a dim `░` hatch. Cell counts come from
+ * `apportionCells`, so the runs always sum to exactly the bar width.
+ */
+function renderContextBar(bd: ContextBreakdown): string {
+  const weights = bd.segments.map((s) => s.tokens);
+  if (bd.windowKnown) weights.push(bd.free);
+  const cells = apportionCells(weights, CONTEXT_BAR_WIDTH);
+  let bar = "";
+  bd.segments.forEach((s, i) => {
+    bar += CONTEXT_SEGMENT_COLOR[s.key]("█".repeat(cells[i] ?? 0));
+  });
+  if (bd.windowKnown) {
+    bar += pc.dim("░".repeat(cells[bd.segments.length] ?? 0));
+  }
+  return bar;
+}
+
+/** One aligned legend row per segment (and Free), colour-matched to the bar. */
+function renderContextLegend(bd: ContextBreakdown): string[] {
+  const rows = bd.segments.map((s) => ({
+    dot: CONTEXT_SEGMENT_COLOR[s.key]("●"),
+    label: s.label,
+    tokens: s.tokens,
+    pct: s.pct,
+  }));
+  if (bd.windowKnown) {
+    rows.push({
+      dot: pc.dim("░"),
+      label: "Free",
+      tokens: bd.free,
+      pct: bd.freePct,
+    });
+  }
+  const labelW = Math.max(...rows.map((r) => r.label.length));
+  const tokW = Math.max(...rows.map((r) => formatTokenCount(r.tokens).length));
+  return rows.map((r) => {
+    const label = r.label.padEnd(labelW);
+    const tok = formatTokenCount(r.tokens).padStart(tokW);
+    const pct = `${r.pct}%`.padStart(6);
+    return `${r.dot} ${label}  ${pc.dim(tok)}  ${pc.dim(pct)}`;
+  });
+}
+
 // ── Built-in commands ────────────────────────────────────────────────────────
 
 export function registerBuiltinCommands(): void {
@@ -393,6 +456,95 @@ export function registerBuiltinCommands(): void {
     },
   });
 
+  registerCommand({
+    name: "context",
+    aliases: ["ctx"],
+    description: "Context-window usage, broken down",
+    async handler(_args, ctx) {
+      const chatId = ctx.chatId();
+      const u = getSessionInfo(chatId).usage;
+      const be = ctx.backend;
+      const activeModel = getChatSettings(chatId).model ?? ctx.config.model;
+
+      // Window + a friendly model name, enriched from the backend like /status.
+      let contextWindow = u.contextWindow;
+      let modelName = resolveModelName(activeModel);
+      if (be?.models?.getRawModelInfo) {
+        const mi = await be.models
+          .getRawModelInfo(activeModel)
+          .catch(() => undefined);
+        if (mi) {
+          if (mi.contextWindow) contextWindow ||= mi.contextWindow;
+          if (mi.displayName) modelName = mi.displayName;
+        }
+      }
+
+      // System = the actual frozen prompt the model is running with. Measure
+      // it directly rather than rebuilding, so the number matches what was
+      // really sent (the prompt is frozen per session by design).
+      const parts = ctx.config.systemPromptParts;
+      const systemText = parts
+        ? [parts.staticText, parts.dynamicText].filter(Boolean).join("\n")
+        : (ctx.config.systemPrompt ?? "");
+      const systemTokens = estimateContextTokens(systemText);
+
+      // Conversation = stored history for this chat. An estimate: the model's
+      // real in-window history may be smaller after compaction, which the
+      // breakdown clamps against the authoritative fill.
+      const history = getRecentHistory(chatId, 2000);
+      const conversationTokens = estimateContextTokens(
+        history.map((m) => m.text ?? "").join("\n"),
+      );
+
+      const bd = buildContextBreakdown({
+        contextTokens: u.contextTokens,
+        contextWindow,
+        systemTokens,
+        conversationTokens,
+      });
+
+      ctx.renderer.writeln();
+      if (!bd.known) {
+        ctx.renderer.writeln(
+          `  ${pc.bold("Context")}  ${pc.dim("no usage yet — send a message first")}`,
+        );
+        ctx.reprompt();
+        return;
+      }
+
+      const windowStr = bd.windowKnown
+        ? `${formatTokenCount(bd.max)} window`
+        : pc.dim("window unknown");
+      ctx.renderer.writeln(
+        `  ${pc.bold("Context")}  ${modelName}  ·  ${windowStr}`,
+      );
+
+      const usedStr = bd.windowKnown
+        ? `${formatTokenCount(bd.used)} / ${formatTokenCount(bd.max)}  ·  ${bd.usedPct}% used`
+        : `${formatTokenCount(bd.used)} used`;
+      ctx.renderer.writeln(
+        `  ${bd.warn ? pc.yellow(usedStr) : pc.dim(usedStr)}${bd.warn ? pc.yellow("  · nearing limit") : ""}`,
+      );
+      ctx.renderer.writeln();
+      ctx.renderer.writeln(`  ${renderContextBar(bd)}`);
+      ctx.renderer.writeln();
+      for (const line of renderContextLegend(bd)) {
+        ctx.renderer.writeln(`  ${line}`);
+      }
+      // Explain only what's on screen: Tools is derivable (and shown) only
+      // when the backend reported a real fill.
+      const hasTools = bd.segments.some((s) => s.key === "tools");
+      ctx.renderer.writeln(
+        `  ${pc.dim(
+          hasTools
+            ? "System measured; Conversation estimated; Tools is the remainder."
+            : "System measured; Conversation estimated from stored history.",
+        )}`,
+      );
+      ctx.reprompt();
+    },
+  });
+
   registerCommand({
     name: "reset",
     description: "Start a fresh session",

package/src/util/paths.ts

@@ -17,7 +17,11 @@
  *       trigger-runs/          Trigger script bodies + run logs
  *     workspace/               User-facing workspace (memory, uploads, logs)
  *       memory/
+ *         memory.md            Durable memory — the dream agent owns it
+ *         state.md             Live operational status — the heartbeat owns
+ *                              it, rewritten in full each run
  *         daily/               Per-day memory notes (YYYY-MM-DD.md)
+ *         archive/             Pruned memory, kept for audit (YYYY-MM.md)
  *       scripts/               Agent script bodies
  *       skills/                Skill folders (SKILL.md + resources)
  *       uploads/
@@ -56,6 +60,12 @@ export const dirs = {
   memory: resolve(TALON_ROOT, "workspace", "memory"),
   /** Daily memory notes: ~/.talon/workspace/memory/daily/ */
   dailyMemory: resolve(TALON_ROOT, "workspace", "memory", "daily"),
+  /**
+   * Pruned-memory archive: ~/.talon/workspace/memory/archive/
+   * Monthly files the dream agent appends to when it drops an entry, so
+   * forgetting stays auditable instead of silent.
+   */
+  memoryArchive: resolve(TALON_ROOT, "workspace", "memory", "archive"),
   /** Sticker packs: ~/.talon/workspace/stickers/ */
   stickers: resolve(TALON_ROOT, "workspace", "stickers"),
   /** Prompt files: ~/.talon/prompts/ */
@@ -110,6 +120,16 @@ export const files = {
   mediaIndex: resolve(TALON_ROOT, "data", "media-index.json"),
   /** Persistent memory: ~/.talon/workspace/memory/memory.md */
   memory: resolve(TALON_ROOT, "workspace", "memory", "memory.md"),
+  /**
+   * Live operational state: ~/.talon/workspace/memory/state.md
+   *
+   * Separate from `memory.md` on purpose. The heartbeat rewrites this file
+   * whole on every run; nothing appends to it. Keeping status snapshots out
+   * of the durable store is what stops "as of Run #N" sections accreting
+   * there — on the live deployment three of them had grown to 15.8k chars,
+   * pushing the actual knowledge past the prompt's injection cap.
+   */
+  state: resolve(TALON_ROOT, "workspace", "memory", "state.md"),
   /** Self-bootstrapping identity: ~/.talon/workspace/identity.md */
   identity: resolve(TALON_ROOT, "workspace", "identity.md"),
   /** Telegram userbot session: ~/.talon/.user-session */