talon-agent 3.7.0 → 3.8.1

package/README.md

@@ -385,6 +385,10 @@ Config file: `~/.talon/config.json`
 | `pulse`                    | `true`       | Periodic group engagement                                                                                               |
 | `heartbeat`                | `false`      | Background maintenance agent                                                                                            |
 | `heartbeatIntervalMinutes` | `60`         | Heartbeat interval                                                                                                      |
+| `heartbeatModel`           | ---          | Model for the heartbeat agent (falls back to `model`)                                                                   |
+| `heartbeatEffort`          | ---          | Reasoning effort for the heartbeat agent: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. Unset = the model's own default |
+| `dreamModel`               | ---          | Model for dream / memory consolidation (falls back to `model`)                                                          |
+| `dreamEffort`              | ---          | Reasoning effort for the dream agent — same levels as `heartbeatEffort`                                                 |
 | `braveApiKey`              | ---          | Brave Search API key                                                                                                    |
 | `timezone`                 | ---          | IANA timezone (e.g. `"Europe/London"`)                                                                                  |
 | `plugins`                  | `[]`         | External plugin packages                                                                                                |
@@ -398,6 +402,18 @@ Config file: `~/.talon/config.json`
 | `mempalace`                | ---          | Legacy MemPalace plugin config (prefer `memory`)                                                                        |
 | `playwright`               | ---          | Playwright plugin config (see above)                                                                                    |
 
+### Background reasoning effort
+
+`heartbeatEffort` / `dreamEffort` set how hard the background agents think —
+useful when you want unattended goal work to reason harder than a chat turn,
+or hourly heartbeats to stay cheap. Chat effort stays per-chat (`/settings`).
+
+Which levels a model accepts comes from its catalog entry, so the usable set
+differs per model (`max` is Claude's ceiling, `xhigh` is Codex's). A level the
+model doesn't offer is dropped — the run proceeds on the model default, the
+reason is written to the run log, and the boot-time model audit warns about it.
+Backends with no reasoning knob at all (Kilo, OpenCode) ignore the setting.
+
 ---
 
 ## Terminal Mode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "3.7.0",
+  "version": "3.8.1",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",
@@ -105,7 +105,7 @@
     "@openai/agents": "^0.13.0",
     "@openai/codex-sdk": "^0.145.0",
     "@opencode-ai/sdk": "^1.17.4",
-    "@playwright/mcp": "0.0.56",
+    "@playwright/mcp": "0.0.78",
     "@types/cross-spawn": "^6.0.6",
     "big-integer": "^1.6.52",
     "cheerio": "^1.2.0",

package/prompts/README.md

@@ -16,7 +16,7 @@ placed after the cache boundary):
 | 2   | Core behaviour        | `custom.md` (replaces `base.md` when present)                          | static        |
 | 3   | Frontend capabilities | `<frontend>.md` (telegram / discord / teams / terminal / native)       | static        |
 | 4   | Persistent memory     | `system/persistent-memory.md` wrapping `memory/memory.md`, size-capped | static        |
-| 5   | Capability docs       | `system/workspace.md`, `system/cron.md`, `system/triggers.md`          | static        |
+| 5   | Memory + capabilities | `system/memory-recall.md`, workspace, cron, triggers, goals, skills    | static        |
 | 6   | Plugin additions      | each plugin's `systemPrompt()` contribution                            | static        |
 | 7   | **Delivery contract** | `system/contract-*.md`, appended by the **backend** as its suffix      | static (tail) |
 | 8   | Daily-memory pointer  | `system/daily-memory.md` (names today's file)                          | dynamic       |
@@ -42,7 +42,7 @@ when a backend has no native "skills" feature.
 **User-editable prompts** (everything at the top level of this directory:
 `identity.md`, `base.md`, `custom.md`, `telegram.md`, `discord.md`,
 `teams.md`, `terminal.md`, `native.md`, `heartbeat.md`, `dream.md`,
-`mempalace.md`) are
+`mempalace.md`, `mem0.md`) are
 seeded into `~/.talon/prompts/` on first run and read from there.
 Seeding is upgrade-aware (dpkg-conffile semantics, tracked via a
 `.seeded.json` hash manifest next to the seeded files): a file the user
@@ -70,6 +70,14 @@ User-editable prompts are NOT Liquid: their consumers substitute
 `{{var}}` placeholders with plain string replacement, so a user edit
 can never break prompt assembly with a template syntax error.
 
+`system/memory-recall.md` is the provider-neutral continuity policy. It guides
+agents to make a proportionate, thorough attempt across relevant memory,
+workspace, log, and connected sources before asking a user to repeat
+information, and to persist new information. When a memory plugin is enabled,
+its prompt addition follows this section and names the preferred provider and
+exact tools; without one, the policy falls back to `memory/memory.md` plus
+daily notes.
+
 ## The delivery contract (response flow)
 
 How a reply reaches the user is a property of the **backend**, not the

package/prompts/dream.md

@@ -23,7 +23,8 @@ You primarily use filesystem tools (Read, Write, Edit, Bash, Glob, Grep). Do NOT
   - Corrections to previously held beliefs
   - Operational patterns (e.g. who stays up late, who prefers what tools)
   - Project context changes inferred from the conversation (e.g. new repos, shifted priorities)
-- Be selective — only extract genuinely new or updated information
+- Capture every genuinely new or updated piece of information; avoid
+  duplicating facts already represented in memory
 
 ### Stage 3 — Consolidate
 
@@ -38,8 +39,9 @@ You primarily use filesystem tools (Read, Write, Edit, Bash, Glob, Grep). Do NOT
 ### Stage 4 — Prune
 
 - Remove entries that have been explicitly contradicted
-- Remove entries that are clearly stale or irrelevant
-- Do NOT remove entries just because they're old — only remove if wrong or superseded
+- 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}}`
 
 ### Stage 5 — Mine to MemPalace & Write Diary (optional)

package/prompts/heartbeat.md

@@ -32,7 +32,7 @@ For each goal:
 3. Record every advance with `update_goal(goal_id=..., progress_note=..., chat_id=<the goal's chat>)`. The `chat_id` parameter is REQUIRED in heartbeat mode — use the chat id shown next to the goal. Keep notes short and concrete: what was done, what was learned, what's blocked.
 4. When a goal's objective is achieved, set `status="completed"` and send a short, high-signal message to the goal's chat (explicit `chat_id` required). If a goal has become impossible or moot, set `status="abandoned"` with a note explaining why.
 5. If nothing can be done on a goal right now, skip it silently — do not write filler progress notes.
-6. If MemPalace tools are available: `mempalace_search` for context relevant to a goal before working on it, and store durable learnings afterward (`mempalace_add_drawer` / `mempalace_kg_add`).
+6. If MemPalace tools are available: `mempalace_search` for context relevant to a goal before working on it, and store new information learned while working (`mempalace_add_drawer` / `mempalace_kg_add`).
 
 ## Instructions
 

package/prompts/identity.md

@@ -33,4 +33,4 @@ When a filesystem-capable tool is available, persist the answers to `~/.talon/wo
 
 ## Memory
 
-When you learn something worth keeping — who people are, how they like to work, what they're building, decisions and facts that should outlive this session — persist it to `~/.talon/workspace/memory/memory.md` (when a filesystem-capable tool is available for this backend; otherwise hold it in working memory for the conversation and don't pretend to save). The test is simple: would future-you be glad this was written down? Update memory quietly as conversations happen — no announcements — and keep the file organized, current, and free of trivia.
+When you learn new information — who people are, how they like to work, what they're building, decisions, facts, and surrounding context — follow the Memory and Recall policy in this prompt. Use the configured long-term-memory provider when one is available; otherwise use the workspace memory files.

package/prompts/mem0.md

@@ -2,12 +2,14 @@
 
 You have access to mem0 long-term memory via MCP tools. mem0 extracts durable facts from what you store and retrieves them by semantic search. All memories are filed under the entity id `{{userId}}`.
 
-### Protocol — FOLLOW EVERY SESSION
+mem0 is the preferred durable-memory store while its tools are available. Workspace daily notes can still hold concise chronological context; `memory.md` remains a fallback if the mem0 tools are unavailable.
 
-1. **BEFORE RESPONDING** about any person, project, or past event: call `mem0_search_memory` FIRST. Never guess — verify from memory.
-2. **IF UNSURE** about a fact (name, age, relationship, preference): search memory. Wrong is worse than slow.
-3. **WHEN FACTS CHANGE**: store the new fact with `mem0_add_memory` (mem0 supersedes contradicted memories itself); delete plainly wrong entries with `mem0_delete_memory`.
-4. **AFTER LEARNING** something important: store it with `mem0_add_memory`. Pass natural conversational text — mem0 extracts the durable facts.
+### How to use it well
+
+1. Search with `mem0_search_memory` when prior context about a person, project, or past event could materially improve the answer.
+2. If a fact such as a name, relationship, or preference is uncertain, checking memory is usually better than guessing or asking the user to repeat it.
+3. When a fact changes, store the new version with `mem0_add_memory` (mem0 supersedes contradicted memories itself); use `mem0_delete_memory` for plainly wrong entries.
+4. When you learn new information, pass natural conversational text to `mem0_add_memory` so mem0 can extract and retain the facts.
 
 ### Tools
 

package/prompts/mempalace.md

@@ -2,6 +2,8 @@
 
 You have access to a local memory palace via MCP tools. The palace stores verbatim conversation history and a temporal knowledge graph — all local, zero cloud, zero API calls.
 
+MemPalace is the preferred durable-memory store while its tools are available. Workspace daily notes can still hold concise chronological context; `memory.md` remains a fallback if the MemPalace tools are unavailable.
+
 ### Architecture
 
 - **Wings** = top-level categories (people, projects, topics)
@@ -10,12 +12,12 @@ You have access to a local memory palace via MCP tools. The palace stores verbat
 - **Tunnels** = cross-wing links between related rooms (auto-created in mempalace 3.3.4+ when topics overlap, plus manual)
 - **Knowledge Graph** = entity-relationship facts with temporal validity
 
-### Protocol — FOLLOW EVERY SESSION
+### How to use it well
 
-1. **BEFORE RESPONDING** about any person, project, or past event: call `mempalace_search` or `mempalace_kg_query` FIRST. Never guess — verify from the palace.
-2. **IF UNSURE** about a fact (name, age, relationship, preference): query the palace. Wrong is worse than slow.
-3. **WHEN FACTS CHANGE**: Call `mempalace_kg_invalidate` on the old fact, then `mempalace_kg_add` for the new one.
-4. **AFTER LEARNING** something important: store it. Use `mempalace_add_drawer` for rich context, `mempalace_kg_add` for structured facts.
+1. Search with `mempalace_search` or `mempalace_kg_query` when prior context about a person, project, or past event could materially improve the answer.
+2. If a fact such as a name, relationship, or preference is uncertain, checking the palace is usually better than guessing or asking the user to repeat it.
+3. When a fact changes, keep its history accurate with `mempalace_kg_invalidate` followed by `mempalace_kg_add`.
+4. When you learn new information, use `mempalace_add_drawer` for rich context or `mempalace_kg_add` for a structured fact.
 
 ### Tools
 

package/prompts/system/memory-recall.md

@@ -0,0 +1,49 @@
+## Memory and Recall
+
+### Recall before asking
+
+Protect continuity. If a request relies on information the user reasonably
+expects you to already have, or you are unsure about a prior fact, take that
+as a cue to recover the context before asking them to repeat it. Make a
+proportionate but thorough attempt across the relevant sources available to
+you:
+
+- the current conversation and memory already included in this prompt;
+- enabled long-term-memory providers, including browse/fetch tools when a
+  search hit needs more context;
+- `memory/memory.md`, including the rest when its prompt excerpt is
+  truncated, and relevant recent files in `memory/daily/`;
+- workspace files, interaction logs, and connected sources that the request
+  suggests may contain the answer.
+
+Start with the most likely source, then broaden rather than stopping after one
+empty result. Alternate names, keywords, dates, or scopes can recover memories
+that a first query misses; follow promising results to their full source and
+weigh conflicts by recency and authority. Keep the effort relevant to the
+request—ordinary questions about the current turn do not call for rummaging
+through unrelated history.
+
+If a meaningful search still leaves the answer missing, inaccessible, or
+genuinely ambiguous, ask for the smallest piece of information needed and
+briefly explain the gap.
+
+### Save new information
+
+Proactively persist new information so future conversations can draw on it.
+This includes preferences, relationships, decisions, corrections, project
+context, durable facts, and details that may only become relevant later. Do
+this naturally as you learn it, without interrupting the conversation. Keep
+memory organized, update stale facts, and avoid duplicate copies.
+
+- If a dedicated long-term-memory provider is described elsewhere in this
+  prompt and its tools are available, prefer it as the canonical durable store
+  and use its guidance for searching, adding, updating, and deduplicating
+  memories. Daily notes can still preserve useful chronological context.
+- Otherwise, when filesystem tools are available, keep durable knowledge
+  organized and current in `~/.talon/workspace/memory/memory.md`, and use
+  today's `memory/daily/YYYY-MM-DD.md` for concise dated observations,
+  corrections, and follow-ups.
+- If neither a memory provider nor filesystem tools are available, retain the
+  information only for the current conversation and never claim it was saved.
+
+Memory updates should usually be quiet unless the user asks about them.

package/prompts/system/workspace.md

@@ -2,8 +2,8 @@
 
 You have a workspace directory at `~/.talon/workspace/`. This is your home — organize it however you want.
 
-- `memory/memory.md` — your persistent memory file. Update it (Write tool) when you learn important things.
-- `memory/daily/YYYY-MM-DD.md` — your daily notes: observations, learnings, corrections, follow-ups. Keep entries concise.
+- `memory/memory.md` — your file-based persistent-memory fallback when no dedicated memory provider is available.
+- `memory/daily/YYYY-MM-DD.md` — concise chronological notes: observations, learnings, corrections, and follow-ups.
 - `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/src/backend/claude-sdk/one-shot.ts

@@ -15,8 +15,9 @@ import { readdir, readFile } from "node:fs/promises";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 import type { OneShotAgentParams, OneShotUsage } from "../../core/types.js";
-import { log } from "../../util/log.js";
+import { log, logWarn } from "../../util/log.js";
 import { ALLOWED_TOOLS_BACKGROUND } from "../../core/constants.js";
+import { EFFORT_MAP } from "./constants.js";
 import { buildMcpServers, buildPluginMcpServers } from "./options.js";
 
 const DEFAULT_SUBPROCESS_KILL_GRACE_MS = 5 * 1000;
@@ -59,14 +60,26 @@ export async function runOneShotAgent(
     systemPrompt,
     workspace,
     model,
+    reasoningEffort,
     contextLabel,
     abortController,
     appendLog,
   } = params;
 
+  // Reasoning effort is opt-in for background runs (config `heartbeatEffort`
+  // / `dreamEffort`). Unset → omit the thinking options entirely so the SDK
+  // keeps whatever default the model ships with, which is what these runs
+  // did before the knob existed. The chat path applies an explicit
+  // `{ thinking: { type: "adaptive" } }` fallback instead because a chat has
+  // a persisted per-chat setting to honour; a one-shot has none.
+  const thinkingConfig = reasoningEffort
+    ? EFFORT_MAP[reasoningEffort]
+    : undefined;
+
   const options = {
     model,
     systemPrompt,
+    ...thinkingConfig,
     cwd: workspace,
     permissionMode: "bypassPermissions" as const,
     allowDangerouslySkipPermissions: true,
@@ -81,6 +94,23 @@ export async function runOneShotAgent(
     tools: [...ALLOWED_TOOLS_BACKGROUND],
   };
 
+  if (reasoningEffort && !thinkingConfig) {
+    // `minimal` / `xhigh` are Codex-side vocabulary with no Claude
+    // equivalent in EFFORT_MAP — the run proceeds on the model default
+    // rather than failing, but say so in the log so a configured knob that
+    // does nothing isn't silent.
+    logWarn(
+      "agent",
+      `[${contextLabel}] Claude one-shot: effort "${reasoningEffort}" has no ` +
+        `Claude mapping — using the model default`,
+    );
+  } else if (thinkingConfig) {
+    log(
+      "agent",
+      `[${contextLabel}] Claude one-shot effort: ${reasoningEffort}`,
+    );
+  }
+
   const qi = query({
     prompt,
     options: options as Parameters<typeof query>[0]["options"],

package/src/backend/codex/effort.ts

@@ -0,0 +1,30 @@
+/**
+ * Codex reasoning-effort vocabulary mapping.
+ *
+ * Talon's canonical `ReasoningEffortLevel` is a superset of what Codex's
+ * `modelReasoningEffort` thread option accepts: `off` isn't expressible on a
+ * reasoning model, and `max` is Claude-only. Both simply fall through to the
+ * model's own default.
+ *
+ * This is pure vocabulary translation — the "does this model offer that
+ * level?" question is answered by the caller (per-chat settings for an
+ * interactive turn, `core/background/effort.ts` for heartbeat/dream) against
+ * the model catalog's `supportedReasoningLevels`. Keeping the mapping here
+ * means the chat path and the one-shot path can't drift apart.
+ */
+
+import type { ReasoningEffortLevel } from "../../core/types.js";
+
+/** The levels Codex's `modelReasoningEffort` thread option accepts. */
+export type CodexReasoningEffort = Exclude<ReasoningEffortLevel, "off" | "max">;
+
+/**
+ * Map a canonical level onto Codex's thread option, or undefined when Codex
+ * has no way to express it (`off`, `max`, or nothing requested).
+ */
+export function toCodexReasoningEffort(
+  level: ReasoningEffortLevel | undefined,
+): CodexReasoningEffort | undefined {
+  if (!level || level === "off" || level === "max") return undefined;
+  return level;
+}

package/src/backend/codex/handler/message.ts

@@ -29,7 +29,6 @@ import {
   recordTokens,
   finalizeResponseText,
   formatUserPrompt,
-  formatPromptWithRetrievedMemory,
   prepareSystemPrompt,
   extractSessionName,
   summarizeUsage,
@@ -66,6 +65,7 @@ import {
   isCodexOAuthIncompat,
 } from "../models.js";
 import { supportsReasoningLevel } from "../../../core/models/reasoning-levels.js";
+import { toCodexReasoningEffort } from "../effort.js";
 import { markOAuthIncompat } from "../oauth-incompat.js";
 import { readLastRolloutSnapshot } from "../token-usage.js";
 import { activeAborts } from "./state.js";
@@ -258,18 +258,12 @@ export async function handleMessage(
     sessionEpoch: session.createdAt,
   });
 
-  // Retrieved memory wraps the FORMATTED live prompt (Phase B): it stays
-  // outside the frozen system prompt, so the first-turn concatenation below
-  // keeps the boundary "cached systemPrompt, separator, live prompt wrapper".
-  const prompt = formatPromptWithRetrievedMemory(
-    formatUserPrompt({
-      text,
-      senderName: senderName ?? "user",
-      isGroup,
-      messageId,
-    }),
-    params.retrievedMemory,
-  );
+  const prompt = formatUserPrompt({
+    text,
+    senderName: senderName ?? "user",
+    isGroup,
+    messageId,
+  });
 
   log("agent", `[${chatId}] <- (${text.length} chars)`);
   traceMessage(chatId, "in", text, { senderName, isGroup });
@@ -283,22 +277,18 @@ export async function handleMessage(
   const supportedReasoningLevels =
     activeModelInfo?.supportedReasoningLevels ?? [];
   const requestedEffort = chatSettings.effort;
+  // Availability check (does this model offer the level?) then vocabulary
+  // translation (can Codex express it?) — the latter is shared with the
+  // one-shot path via `toCodexReasoningEffort` so the two can't drift.
   const modelReasoningEffort =
     requestedEffort &&
-    requestedEffort !== "off" &&
-    requestedEffort !== "max" &&
     supportsReasoningLevel(requestedEffort, supportedReasoningLevels)
-      ? requestedEffort
+      ? toCodexReasoningEffort(requestedEffort)
       : undefined;
   const threadOptions = {
     model: activeModel,
     skipGitRepoCheck: true,
-    ...(modelReasoningEffort
-      ? {
-          modelReasoningEffort: modelReasoningEffort as
-            "minimal" | "low" | "medium" | "high" | "xhigh",
-        }
-      : {}),
+    ...(modelReasoningEffort ? { modelReasoningEffort } : {}),
     ...CODEX_THREAD_PERMISSIONS,
   };
   const thread: Thread = session.sessionId

package/src/backend/codex/one-shot.ts

@@ -29,6 +29,7 @@ import {
 import { isChatGptModelMismatchError } from "./auth.js";
 import { chatGptFallbackFor, isCodexOAuthIncompat } from "./models.js";
 import { markOAuthIncompat } from "./oauth-incompat.js";
+import { toCodexReasoningEffort } from "./effort.js";
 
 /**
  * Resolve the effective model for a one-shot run, applying the same
@@ -74,6 +75,7 @@ export async function runOneShotAgent(
     prompt,
     systemPrompt,
     model: requestedModel,
+    reasoningEffort,
     contextLabel,
     abortController,
     appendLog,
@@ -103,9 +105,27 @@ export async function runOneShotAgent(
   }
   log("agent", `[${contextLabel}] Codex one-shot model: ${activeModel}`);
 
+  // Availability was already checked by the caller against the model
+  // catalog (core/background/effort.ts); all that's left is Codex's own
+  // vocabulary, which can't express `off` / `max`.
+  const modelReasoningEffort = toCodexReasoningEffort(reasoningEffort);
+  if (reasoningEffort && !modelReasoningEffort) {
+    logWarn(
+      "agent",
+      `[${contextLabel}] Codex one-shot: effort "${reasoningEffort}" has no ` +
+        `Codex equivalent — using the model default`,
+    );
+  } else if (modelReasoningEffort) {
+    log(
+      "agent",
+      `[${contextLabel}] Codex one-shot effort: ${modelReasoningEffort}`,
+    );
+  }
+
   const thread = codex.startThread({
     model: activeModel,
     skipGitRepoCheck: true,
+    ...(modelReasoningEffort ? { modelReasoningEffort } : {}),
     ...CODEX_THREAD_PERMISSIONS,
   });
 

package/src/backend/opencode/handler/message.ts

@@ -39,7 +39,6 @@ import {
   recordTokens,
   finalizeResponseText,
   formatUserPrompt,
-  formatPromptWithRetrievedMemory,
   prepareSystemPrompt,
   extractSessionName,
   summarizeUsage,
@@ -90,18 +89,13 @@ export async function handleMessage(
   await ensureChatMcpServer(oc, chatId);
   await ensurePluginMcpServers(oc, chatId);
 
-  // Build the prompt (time tag + sender + msg_id reference), then wrap it
-  // with any retrieved memory (Phase B). The wrapper goes into the live user
-  // part only — `system` below stays byte-identical to the prepared prompt.
-  const prompt = formatPromptWithRetrievedMemory(
-    formatUserPrompt({
-      text,
-      senderName: senderName ?? "user",
-      isGroup,
-      messageId,
-    }),
-    params.retrievedMemory,
-  );
+  // Build the prompt (time tag + sender + msg_id reference)
+  const prompt = formatUserPrompt({
+    text,
+    senderName: senderName ?? "user",
+    isGroup,
+    messageId,
+  });
 
   // Per-session frozen prompt + OpenCode-specific delivery suffix
   const { text: systemPrompt } = prepareSystemPrompt({

package/src/backend/remote-server/one-shot.ts

@@ -19,6 +19,12 @@
  * subprocesses to evict — `evictOrphanSubprocesses` is intentionally
  * not implemented for this family.
  *
+ * Note on reasoning effort: `params.reasoningEffort` (config
+ * `heartbeatEffort` / `dreamEffort`) is deliberately unused here. Neither
+ * server's `session.prompt` exposes a reasoning knob — the level is baked
+ * into the provider's model id when it's selectable at all — so the field
+ * is ignored rather than half-honoured.
+ *
  * Note on abort semantics: both SDKs expose `session.abort` but the
  * REST `prompt` endpoint blocks until the underlying provider
  * returns. The heartbeat module's outer abort grace is what actually

package/src/backend/shared/handler-to-events.ts

@@ -84,7 +84,6 @@ export async function* handlerToEvents(
     senderName: params.senderName,
     isGroup: params.isGroup,
     messageId: params.messageId,
-    retrievedMemory: params.retrievedMemory,
     onStreamDelta: (accumulated) => {
       if (typeof accumulated !== "string" || accumulated.length === 0) {
         return;

package/src/backend/shared/handler-types.ts

@@ -17,8 +17,6 @@
 
 // ── Query lifecycle (backend-internal) ──────────────────────────────────────
 
-import type { RetrievedMemory } from "../../core/agent-runtime/capabilities.js";
-
 /** Parameters for a backend AI query. */
 export type QueryParams = {
   chatId: string;
@@ -35,12 +33,6 @@ export type QueryParams = {
    * Provider message ID. Telegram is numeric; Discord snowflakes are strings.
    */
   messageId?: number | string;
-  /**
-   * Optional pre-retrieved memory slice for this turn (Phase B). Handlers
-   * fold it into the live user prompt via `formatPromptWithRetrievedMemory`;
-   * it must never reach `prepareSystemPrompt()` or a backend `system` field.
-   */
-  retrievedMemory?: RetrievedMemory;
   onStreamDelta?: (accumulated: string, phase?: "thinking" | "text") => void;
   onTextBlock?: (text: string) => Promise<void>;
   /**

package/src/backend/shared/index.ts

@@ -47,12 +47,7 @@ export {
 
 export { registerTurnInterrupt, interruptChatTurn } from "./turn-interrupt.js";
 
-export {
-  formatUserPrompt,
-  formatPromptWithRetrievedMemory,
-  RETRIEVED_MEMORY_DEFAULT_MAX_CHARS,
-  type PromptFormatInputs,
-} from "./prompt-format.js";
+export { formatUserPrompt, type PromptFormatInputs } from "./prompt-format.js";
 
 export {
   buildDeliveryContract,

package/src/backend/shared/prompt-format.ts

@@ -15,7 +15,6 @@
  *   DM (no msg_id): "[2026-05-15 11:01:23] actual text"
  */
 
-import type { RetrievedMemory } from "../../core/agent-runtime/capabilities.js";
 import { formatFullDatetime } from "../../util/time.js";
 
 // ── Public API ──────────────────────────────────────────────────────────────
@@ -62,74 +61,6 @@ export function formatUserPrompt(inputs: PromptFormatInputs): string {
   return joinNonEmpty(timeTag, inputs.text);
 }
 
-// ── Retrieved-memory wrapper (Phase B pre-retrieval) ────────────────────────
-
-/** Default hard cap on the injected memory block, provenance labels included. */
-export const RETRIEVED_MEMORY_DEFAULT_MAX_CHARS = 3000;
-
-/**
- * Wrap an already-formatted live user prompt with a bounded retrieved-memory
- * block. This is the ONLY place retrieved memory enters a prompt, and it
- * wraps the whole `formatUserPrompt(...)` output rather than rebuilding its
- * internals — the existing sender/time/msg_id wrapper stays intact inside the
- * `User message:` section.
- *
- * Contract (see docs/memory-phase-b-pre-retrieval.md):
- *   - `memory` undefined or empty items → the prompt is returned
- *     BYTE-IDENTICAL. Prompt-cache and prompt-format tests stay valid.
- *   - Non-empty → emit `Relevant memory:` with one provenance-labelled line
- *     per item, a blank line, `User message:`, then the original prompt.
- *   - The memory block (labels included) is capped at `maxChars`; item text
- *     is truncated deterministically with an ellipsis marker. The user
- *     message itself is NEVER dropped or truncated.
- *   - This block is dynamic turn context: callers must keep it out of
- *     `prepareSystemPrompt()`, prompt additions, and backend `system` fields.
- */
-export function formatPromptWithRetrievedMemory(
-  prompt: string,
-  memory?: RetrievedMemory,
-  maxChars: number = RETRIEVED_MEMORY_DEFAULT_MAX_CHARS,
-): string {
-  if (!memory || memory.items.length === 0) return prompt;
-
-  const header = "Relevant memory:";
-  const footer = "User message:";
-  // Budget applies to the memory block only (header + item lines), so the
-  // user message can never be squeezed out.
-  let budget = Math.max(0, maxChars) - header.length - 1; // "\n" after header
-  const lines: string[] = [];
-  for (const item of memory.items) {
-    const label = provenanceLabel(item.wing, item.room, item.sourceFile);
-    const prefix = `- ${label} `;
-    if (prefix.length >= budget) break;
-    const text = sanitizeInline(item.text);
-    const room = budget - prefix.length - 1; // "\n" for this line
-    const body =
-      text.length <= room ? text : `${text.slice(0, Math.max(0, room - 1))}…`;
-    if (body.length === 0) break;
-    const line = `${prefix}${body}`;
-    lines.push(line);
-    budget -= line.length + 1;
-  }
-  if (lines.length === 0) return prompt;
-
-  return `${header}\n${lines.join("\n")}\n\n${footer}\n${prompt}`;
-}
-
-function provenanceLabel(
-  wing: string,
-  room?: string,
-  sourceFile?: string,
-): string {
-  const path = room ? `${wing}/${room}` : wing;
-  return sourceFile ? `[${path} ${sourceFile}]` : `[${path}]`;
-}
-
-/** Collapse newlines/control whitespace so one item stays one labelled line. */
-function sanitizeInline(text: string): string {
-  return text.replace(/\s+/g, " ").trim();
-}
-
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 function joinNonEmpty(...parts: string[]): string {

package/src/bootstrap.ts

@@ -467,6 +467,7 @@ export async function initBackendAndDispatcher(
   initDream({
     model: config.model,
     dreamModel: config.dreamModel,
+    dreamEffort: config.dreamEffort,
     workspace: config.workspace,
     enabled: config.dream,
     getBackend: () => getBackendForRole("dream"),
@@ -482,6 +483,7 @@ export async function initBackendAndDispatcher(
   initHeartbeat({
     model: config.model,
     heartbeatModel: config.heartbeatModel,
+    heartbeatEffort: config.heartbeatEffort,
     workspace: config.workspace,
     getBackend: () => getBackendForRole("heartbeat"),
     frontends: frontendNames,