talon-agent 4.6.1 → 5.0.0

package/src/backend/{shared → runtime/turn}/handler-to-events.ts

@@ -19,14 +19,34 @@
 import {
   type AgentEvent,
   classifiedToAgentError,
-} from "../../core/agent-runtime/events.js";
-import { classify } from "../../core/errors.js";
-import type { ChatRunParams } from "../../core/agent-runtime/capabilities.js";
+} from "../../../core/agent-runtime/events.js";
+import { classify } from "../../../core/errors.js";
+import type { ChatRunParams } from "../../../core/agent-runtime/capabilities.js";
 import type { QueryParams, QueryResult } from "./handler-types.js";
 import { buildResultEvents } from "./result-events.js";
 
 const SENTINEL = Symbol("handler-to-events:sentinel");
 
+/**
+ * The DATA half of `QueryParams`, carried verbatim from the canonical
+ * `ChatRunParams` (only `ModelRef` flattens to `model.id`). The
+ * callback half is the queue's and is built per run below. Keeping the
+ * carry in one place is what stops a field — `retrievedMemory` being
+ * the one #639 lost — from reaching some handlers and not others.
+ */
+function turnFields(params: ChatRunParams) {
+  return {
+    chatId: params.chatId,
+    model: params.model.id,
+    text: params.text,
+    senderName: params.senderName,
+    senderHandle: params.senderHandle,
+    isGroup: params.isGroup,
+    messageId: params.messageId,
+    retrievedMemory: params.retrievedMemory,
+  };
+}
+
 type QueueEvent = AgentEvent | typeof SENTINEL;
 
 /**
@@ -79,13 +99,7 @@ export async function* handlerToEvents(
   let lastAccumulated = "";
 
   const handlerParams: QueryParams = {
-    chatId: params.chatId,
-    model: params.model.id,
-    text: params.text,
-    senderName: params.senderName,
-    senderHandle: params.senderHandle,
-    isGroup: params.isGroup,
-    messageId: params.messageId,
+    ...turnFields(params),
     onStreamDelta: (accumulated) => {
       if (typeof accumulated !== "string" || accumulated.length === 0) {
         return;

package/src/backend/{shared → runtime/turn}/handler-types.ts

@@ -10,7 +10,7 @@
  * stream loop that `handler-to-events.ts` adapts onto the native
  * `AsyncIterable<AgentEvent>` shape at the factory boundary.
  *
- * Living in `backend/shared/` keeps `core/types.ts` clean of any
+ * Living in `backend/runtime/turn/` keeps `core/types.ts` clean of any
  * implementation-detail shapes, so the dispatcher / cron / triggers /
  * frontends never accidentally couple to the callback contract.
  */
@@ -35,6 +35,12 @@ export type QueryParams = {
    * Provider message ID. Telegram is numeric; Discord snowflakes are strings.
    */
   messageId?: number | string;
+  /**
+   * Per-turn retrieved memory, carried verbatim from `ChatRunParams`.
+   * The handler passes it to `formatUserPrompt` and does nothing else
+   * with it — see `backend/runtime/prompt/prompt-format.ts`.
+   */
+  retrievedMemory?: string;
   onStreamDelta?: (accumulated: string, phase?: "thinking" | "text") => void;
   onTextBlock?: (text: string) => Promise<void>;
   /**

package/src/backend/{shared → runtime/turn}/model-retry.ts

@@ -21,8 +21,8 @@
  * model swap) because those touch backend-specific storage.
  */
 
-import type { TalonError } from "../../core/errors.js";
-import { getFallbackModel } from "../../core/models/catalog.js";
+import type { TalonError } from "../../../core/errors.js";
+import { getFallbackModel } from "../../../core/models/catalog.js";
 
 // ── Public API ──────────────────────────────────────────────────────────────
 

package/src/backend/{shared → runtime/turn}/result-events.ts

@@ -5,8 +5,8 @@
  * logging imports so the adapter stays a pure event translator.
  */
 
-import type { AgentEvent } from "../../core/agent-runtime/events.js";
-import type { TokenUsageSnapshot } from "./usage.js";
+import type { AgentEvent } from "../../../core/agent-runtime/events.js";
+import type { TokenUsageSnapshot } from "../usage.js";
 
 export function buildResultEvents(inputs: {
   text: string;

package/src/backend/{shared → runtime/turn}/stream-state.ts

@@ -20,8 +20,8 @@
  */
 
 import { captureDeliveredText } from "./delivered-text.js";
-import { isTurnTerminator, stripMcpPrefix } from "../../core/tools/index.js";
-import { updateLiveTurn } from "../../storage/sessions.js";
+import { isTurnTerminator, stripMcpPrefix } from "../../../core/tools/index.js";
+import { updateLiveTurn } from "../../../storage/sessions.js";
 
 // ── State shape ─────────────────────────────────────────────────────────────
 

package/src/backend/{shared → runtime/turn}/turn-interrupt.ts

@@ -17,8 +17,8 @@
  * partial text and real usage — never as an error, never as a retry.
  */
 
-import { log, logWarn } from "../../util/log.js";
-import { incrementCounter } from "../../storage/metrics.js";
+import { log, logWarn } from "../../../util/log.js";
+import { incrementCounter } from "../../../storage/metrics.js";
 
 const interrupts = new Map<string, () => void | Promise<void>>();
 

package/src/backend/{shared → runtime/turn}/turn-phases.ts

@@ -23,10 +23,10 @@ import {
   recordUsage,
   setSessionId,
   setSessionName,
-} from "../../storage/sessions.js";
-import { log } from "../../util/log.js";
-import { extractSessionName } from "../../util/session-name.js";
-import { traceMessage } from "../../util/trace.js";
+} from "../../../storage/sessions.js";
+import { log } from "../../../util/log.js";
+import { extractSessionName } from "../../../util/session-name.js";
+import { traceMessage } from "../../../util/trace.js";
 import {
   FLOW_VIOLATION_MAX_RETRIES,
   detectFlowViolation,
@@ -37,9 +37,9 @@ import {
   recordFailedTurnAccounting,
   recordFlowViolation,
   recordTurnMetrics,
-} from "./metrics.js";
+} from "../metrics.js";
 import type { StreamState } from "./stream-state.js";
-import { summarizeUsage, type TokenUsageSnapshot } from "./usage.js";
+import { summarizeUsage, type TokenUsageSnapshot } from "../usage.js";
 
 // ── Usage snapshot ──────────────────────────────────────────────────────────
 

package/src/bootstrap.ts

@@ -24,16 +24,16 @@ import {
 } from "./core/engine/dispatcher.js";
 import { bus } from "./core/bus/index.js";
 import { appendToJournal } from "./storage/journal.js";
-import { initPulse, resetPulseTimer } from "./core/background/pulse.js";
-import { initCron } from "./core/background/cron.js";
-import { initPlanAlerts } from "./core/background/plan-alerts.js";
+import { initPulse, resetPulseTimer } from "./core/background/pulse/pulse.js";
+import { initCron } from "./core/background/cron/scheduler.js";
+import { initPlanAlerts } from "./core/background/pulse/plan-alerts.js";
 import { setAdminNotifier } from "./core/frontend-runtime/admin-notify.js";
 import { startAuthExpiryMonitor } from "./core/auth/expiry-monitor.js";
 import {
   initTriggers,
   resumeAfterRestart as resumeTriggersAfterRestart,
 } from "./core/background/triggers/index.js";
-import { initDream, maybeStartDream } from "./core/background/dream.js";
+import { initDream, maybeStartDream } from "./core/background/dream/index.js";
 import { initHeartbeat } from "./core/background/heartbeat/index.js";
 import { log, logWarn, logDebug } from "./util/log.js";
 import { bootPhase } from "./util/boot-timer.js";
@@ -489,21 +489,6 @@ export async function initBackendAndDispatcher(
   // alerts above.
   wireAdminNotifier(config, frontends);
 
-  // Soul — initialize the identity kernel singleton from config so the prompt
-  // injection / dream hooks see the right enabled state. Off by default; a
-  // failure here must never block startup.
-  try {
-    const { SoulService, setSoul } = await import("./core/soul/service.js");
-    setSoul(
-      SoulService.create({
-        enabled: config.soul?.enabled ?? false,
-        ...(config.soul?.path ? { path: config.soul.path } : {}),
-      }),
-    );
-  } catch (err) {
-    log("soul", `init skipped: ${String(err)}`);
-  }
-
   // Only enable mempalace dream integration if the plugin actually registered
   let mempalaceCfg: { pythonPath: string; palacePath: string } | undefined;
   if (config.mempalace?.enabled) {

package/src/cli.ts

@@ -17,7 +17,7 @@
  */
 
 import { MCP_LAUNCH_SUBCOMMAND, runSupervisor } from "./util/mcp-launcher.js";
-import { LUA_RUN_SUBCOMMAND, runLuaMain } from "./core/scripting/lua-runner.js";
+import { LUA_RUN_SUBCOMMAND, runLuaMain } from "./core/scripts/lua.js";
 
 // Hidden subcommand dispatch — must run before anything else. Talon
 // supervises MCP stdio children (`_mcp-launch`) and runs WASM-sandboxed

package/src/core/agent-runtime/capabilities.ts

@@ -56,6 +56,17 @@ export interface ChatRunParams {
   isGroup?: boolean;
   /** Provider message ID. Telegram is numeric; Discord snowflakes are strings. */
   messageId?: number | string;
+  /**
+   * Memory retrieved for this turn by `core/memory/turn-retrieval.ts`,
+   * already ranked, trust-filtered and budgeted. The Weaver resolves it
+   * before the call; a backend's only job is to hand it to
+   * `formatUserPrompt`, which owns the rendering.
+   *
+   * Turn-scoped and user-turn-only: it must never reach
+   * `prepareSystemPrompt()` or a backend `system` field, or the
+   * per-session frozen prompt stops being frozen (plan §3.6).
+   */
+  retrievedMemory?: string;
 }
 
 // ── Catalog types ───────────────────────────────────────────────────────────

package/src/core/agent-runtime/contract-tests.ts

@@ -199,6 +199,80 @@ export async function assertCompletedUsageMatchesUsageEvent(
   }
 }
 
+/**
+ * `ChatRunParams.retrievedMemory` must reach the prompt the backend
+ * sends, in the USER turn, after the message text.
+ *
+ * This is the clause #639 was written in the absence of: the old
+ * pre-retrieval field was honoured by two backends and dropped in
+ * silence by the other four, a divergence that would have become a
+ * real bug the day a retriever existed. Now there is one renderer
+ * (`backend/runtime/prompt/prompt-format.ts`) that every backend already calls
+ * for its time tag and `msg_id` framing — and this assertion is what
+ * stops a backend from quietly building its prompt some other way.
+ *
+ * The caller supplies `capturePrompt`, returning the prompt the
+ * backend built for the last run: `core/` cannot import `backend/`, so
+ * the rendering itself is asserted by the caller, which can. `marker`
+ * is the retrieved text; it must appear after the user's own text, and
+ * must not appear at all when the field is absent.
+ */
+export async function assertChatBackendCarriesRetrievedMemory(
+  backend: Backend,
+  capturePrompt: () => string | undefined,
+  options: { text?: string; chatId?: string; marker?: string } = {},
+): Promise<void> {
+  const chat = backend.chat;
+  if (!chat) return;
+  const text = options.text ?? "ping";
+  const marker = options.marker ?? "#1 [fact] contract: remembered thing";
+  const run = async (retrievedMemory?: string): Promise<string> => {
+    await drain(
+      chat.runChatTurn({
+        chatId: options.chatId ?? "contract-test-chat",
+        model: makeBareModelRef(backend.id, "contract-test-model"),
+        text,
+        senderName: "ContractTest",
+        ...(retrievedMemory !== undefined ? { retrievedMemory } : {}),
+      }),
+    );
+    const prompt = capturePrompt();
+    if (prompt === undefined) {
+      throw new ContractViolation(
+        backend.id,
+        "ChatBackend.carriesRetrievedMemory",
+        "the backend built no prompt for the turn",
+      );
+    }
+    return prompt;
+  };
+
+  const withMemory = await run(marker);
+  if (!withMemory.includes(marker)) {
+    throw new ContractViolation(
+      backend.id,
+      "ChatBackend.carriesRetrievedMemory",
+      `retrievedMemory never reached the prompt: ${JSON.stringify(withMemory)}`,
+    );
+  }
+  if (withMemory.indexOf(marker) < withMemory.indexOf(text)) {
+    throw new ContractViolation(
+      backend.id,
+      "ChatBackend.carriesRetrievedMemory",
+      "the memory block precedes the user text; it must be appended after it",
+    );
+  }
+
+  const without = await run();
+  if (without.includes(marker)) {
+    throw new ContractViolation(
+      backend.id,
+      "ChatBackend.carriesRetrievedMemory",
+      "the memory block appeared in a turn that carried no retrievedMemory",
+    );
+  }
+}
+
 /**
  * Backends that expose a `BackgroundRunner` must terminate with
  * `completed` or `error` and must emit `run_started` first — same
@@ -323,7 +397,16 @@ export async function assertUsageTelemetryShape(
  */
 export async function assertBackendContract(
   backend: Backend,
-  options: { text?: string; chatId?: string } = {},
+  options: {
+    text?: string;
+    chatId?: string;
+    /**
+     * The prompt the backend built for the last run, when the fixture
+     * can capture it. Supplying it opts the turn-retrieval clause into
+     * the suite; omitting it skips that clause only.
+     */
+    capturePrompt?: () => string | undefined;
+  } = {},
 ): Promise<string[]> {
   const checked: string[] = [];
 
@@ -336,6 +419,14 @@ export async function assertBackendContract(
     checked.push("ChatBackend.singleUsage");
     await assertCompletedUsageMatchesUsageEvent(backend, options);
     checked.push("ChatBackend.completedUsageMatches");
+    if (options.capturePrompt) {
+      await assertChatBackendCarriesRetrievedMemory(
+        backend,
+        options.capturePrompt,
+        options,
+      );
+      checked.push("ChatBackend.carriesRetrievedMemory");
+    }
   }
   if (backend.background) {
     await assertBackgroundRunnerLifecycle(backend);

package/src/core/agent-runtime/events.ts

@@ -9,7 +9,7 @@
  * longer render markdown logs themselves and core no longer parses
  * backend-specific output.
  *
- * The shared wrapper `backend/shared/handler-to-events.ts` converts
+ * The shared wrapper `backend/runtime/turn/handler-to-events.ts` converts
  * each backend's existing callback-driven `handleMessage` into the
  * canonical sequence: `run_started → text_delta* →
  * assistant_message* → tool_call* → usage → completed`. Backends

package/src/core/background/{isolated-agent.ts → cron/isolated-agent.ts}

@@ -14,9 +14,9 @@
  * unset to avoid sweeping the other context's subprocesses.
  */
 
-import type { BackgroundRunner } from "../agent-runtime/capabilities.js";
-import type { OneShotAgentParams, OneShotUsage } from "../types.js";
-import { logWarn, logError } from "../../util/log.js";
+import type { BackgroundRunner } from "../../agent-runtime/capabilities.js";
+import type { OneShotAgentParams, OneShotUsage } from "../../types.js";
+import { logWarn, logError } from "../../../util/log.js";
 
 /** Default bounded grace after an abort before giving up on the backend. */
 const DEFAULT_ABORT_GRACE_MS = 30 * 1000;

package/src/core/background/{job-health.ts → cron/job-health.ts}

@@ -22,7 +22,7 @@ import {
   CLOSED_BREAKER,
   stepBreaker,
   type Breaker,
-} from "../../native/scheduler-core.js";
+} from "../../../native/scheduler-core.js";
 
 export type JobHealthOptions = {
   /** Consecutive failures before the breaker opens. */

package/src/core/background/{job-oneshot.ts → cron/job-oneshot.ts}

@@ -14,14 +14,14 @@
  */
 
 import { mkdir, appendFile } from "node:fs/promises";
-import { dirs } from "../../util/paths.js";
-import { log, logWarn } from "../../util/log.js";
+import { dirs } from "../../../util/paths.js";
+import { log, logWarn } from "../../../util/log.js";
 import {
   acquireBackendInstance,
   isModelValidForBackend,
-} from "../engine/backend-controller/index.js";
-import { taskTable } from "../tasks/index.js";
-import type { OneShotAgentParams } from "../types.js";
+} from "../../engine/backend-controller/index.js";
+import { taskTable } from "../../tasks/index.js";
+import type { OneShotAgentParams } from "../../types.js";
 import { runIsolatedAgent } from "./isolated-agent.js";
 import {
   buildJobSystemPrompt,

package/src/core/background/{job-prompt.ts → cron/job-prompt.ts}

@@ -5,7 +5,7 @@
  */
 
 import { resolve } from "node:path";
-import { dirs } from "../../util/paths.js";
+import { dirs } from "../../../util/paths.js";
 
 export type JobKind = "trigger" | "cron";
 

package/src/core/background/{cron.ts → cron/scheduler.ts}

@@ -20,7 +20,7 @@
  */
 
 import { Cron } from "croner";
-import { getActiveCount } from "../engine/dispatcher.js";
+import { getActiveCount } from "../../engine/dispatcher.js";
 import {
   getAllCronJobs,
   getCronJob,
@@ -31,10 +31,10 @@ import {
   describeSchedule,
   type CronJob,
   type CronRunOutcome,
-} from "../../storage/cron.js";
-import { appendDailyLog } from "../../storage/daily-log.js";
-import { log, logError, logWarn } from "../../util/log.js";
-import { numericChatIdFor } from "../../util/chat-id.js";
+} from "../../../storage/cron.js";
+import { appendDailyLog } from "../../../storage/daily-log.js";
+import { log, logError, logWarn } from "../../../util/log.js";
+import { numericChatIdFor } from "../../../util/chat-id.js";
 import { runJobOneShot } from "./job-oneshot.js";
 import {
   jobAllowsRun,
@@ -46,7 +46,7 @@ import {
 import {
   catchupRunCount,
   missedRunCount,
-} from "../../native/scheduler-core.js";
+} from "../../../native/scheduler-core.js";
 
 // ── Dependencies (injected at startup) ──────────────────────────────────────
 

package/src/core/background/{cron-spec.ts → cron/spec.ts}

@@ -18,7 +18,7 @@ import {
   type CatchupPolicy,
   type CronJob,
   type CronJobType,
-} from "../../storage/cron.js";
+} from "../../../storage/cron.js";
 
 /** The scheduler ticks once a minute, so sub-minute intervals are meaningless. */
 const MIN_INTERVAL_SECONDS = 60;

package/src/core/background/{dream.ts → dream/index.ts}

@@ -13,18 +13,17 @@
 
 import { existsSync, mkdirSync, appendFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { files as pathFiles, dirs } from "../../util/paths.js";
-import { kvGet, kvSet } from "../../storage/kv.js";
-import { importLegacyJson } from "../../storage/legacy-import.js";
+import { files as pathFiles, dirs } from "../../../util/paths.js";
+import { kvGet, kvSet } from "../../../storage/kv.js";
+import { importLegacyJson } from "../../../storage/legacy-import.js";
 import { readPromptAsset } from "#prompt-assets";
-import { log, logError, logWarn } from "../../util/log.js";
-import { getDefaultModel } from "../models/catalog.js";
-import type { OneShotAgentParams, ReasoningEffortLevel } from "../types.js";
-import type { Backend } from "../agent-runtime/capabilities.js";
-import { getSoul } from "../soul/service.js";
-import { taskTable } from "../tasks/index.js";
-import { resolveBackgroundEffort } from "./effort.js";
-import { FailureBackoff } from "./failure-backoff.js";
+import { log, logError, logWarn } from "../../../util/log.js";
+import { getDefaultModel } from "../../models/catalog.js";
+import type { OneShotAgentParams, ReasoningEffortLevel } from "../../types.js";
+import type { Backend } from "../../agent-runtime/capabilities.js";
+import { taskTable } from "../../tasks/index.js";
+import { resolveBackgroundEffort } from "../effort.js";
+import { FailureBackoff } from "../failure-backoff.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -160,10 +159,6 @@ async function executeDream(trigger: "auto" | "forced"): Promise<void> {
       "dream",
       `Memory consolidation complete (${trigger}), log: ${dreamLogPath}`,
     );
-    // The soul's organic maintenance shares the dream cadence. Inert (no-op)
-    // unless the soul is enabled, and isolated so a soul failure never breaks
-    // memory consolidation.
-    await getSoul().dream();
   } catch (err) {
     logError("dream", `Memory consolidation failed (${trigger})`, err);
     writeDreamState({ last_run: state?.last_run ?? 0, status: "idle" });

package/src/core/background/{plan-alerts.ts → pulse/plan-alerts.ts}

@@ -11,9 +11,9 @@
  * also what covers windows the plan reports no reset for).
  */
 
-import { getPooledBackend } from "../engine/backend-controller/index.js";
-import { log, logWarn } from "../../util/log.js";
-import { formatSmartTimestamp } from "../../util/time.js";
+import { getPooledBackend } from "../../engine/backend-controller/index.js";
+import { log, logWarn } from "../../../util/log.js";
+import { formatSmartTimestamp } from "../../../util/time.js";
 
 const CHECK_INTERVAL_MS = 5 * 60_000;
 

package/src/core/background/{pulse.ts → pulse/pulse.ts}

@@ -8,16 +8,19 @@
  * Knows nothing about the backend or frontend — uses the dispatcher.
  */
 
-import { execute, getActiveCount } from "../engine/dispatcher.js";
+import { execute, getActiveCount } from "../../engine/dispatcher.js";
 import {
   setChatPulse,
   getRegisteredPulseChats,
   getChatSettings,
   setPulseLastCheckMsgId,
-} from "../../storage/chat-settings.js";
-import { getRecentHistory, getLatestMessageId } from "../../storage/history.js";
-import { log, logError } from "../../util/log.js";
-import { formatSmartTimestamp } from "../../util/time.js";
+} from "../../../storage/chat-settings.js";
+import {
+  getRecentHistory,
+  getLatestMessageId,
+} from "../../../storage/history.js";
+import { log, logError } from "../../../util/log.js";
+import { formatSmartTimestamp } from "../../../util/time.js";
 
 // ── State ────────────────────────────────────────────────────────────────────
 

package/src/core/background/triggers/command.ts

@@ -7,7 +7,7 @@
 import { spawnSync } from "node:child_process";
 import type { Trigger } from "../../../storage/triggers.js";
 import { selfInvocation } from "../../../util/mcp-launcher.js";
-import { LUA_RUN_SUBCOMMAND } from "../../scripting/lua-runner.js";
+import { LUA_RUN_SUBCOMMAND } from "../../scripts/lua.js";
 
 export function commandForLanguage(
   lang: Trigger["language"],

package/src/core/config/index.ts

@@ -557,16 +557,11 @@ const configSchema = z.object({
   // Playwright — headless browser automation via MCP
   playwright: playwrightConfigSchema.optional(),
 
-  // Soul — compiled, self-organizing identity kernel (experimental).
-  // Off by default; when enabled, the projected identity surface is injected
-  // into the system prompt and the organic pass runs on the dream cadence.
-  soul: z
-    .object({
-      enabled: z.boolean().default(false),
-      /** Kernel persistence path (default: ~/.talon/data/soul.json) */
-      path: z.string().min(1).optional(),
-    })
-    .optional(),
+  // Soul — the compiled identity kernel, removed in #953. The root schema
+  // is `.strict()`, so a key that simply disappeared would make every
+  // existing config.json fail to parse; accepted and ignored instead, with
+  // one warning at load so the operator knows to drop it.
+  soul: z.unknown().optional(),
 
   // Discord — discord.js v14-based frontend
   discord: discordConfigSchema.optional(),
@@ -741,6 +736,15 @@ export function loadConfig(): TalonConfig {
 
   const parsed = configSchema.parse(fileConfig);
 
+  // The soul kernel is gone (#953). Its config block still parses so an
+  // existing config.json keeps loading, but it no longer does anything —
+  // say so once rather than silently ignoring it.
+  if (parsed.soul !== undefined) {
+    console.warn(
+      `Ignoring "soul" in ${CONFIG_FILE}: the soul kernel was removed; its message taps now write to the memory store. Remove the key.`,
+    );
+  }
+
   // Unified memory section: mirror the selected backend onto the per-plugin
   // section the loaders consume (builtins.ts reads config.mempalace /
   // config.mem0). The memory section wins over a legacy section when both
@@ -827,7 +831,7 @@ export function primaryFrontend(config: TalonConfig): string {
  * the config. Multi-frontend deployments need per-chat prompt
  * flavours (a native-app chat must get native.md guidance, not the
  * telegram.md that `frontends[0]` happens to be) — the per-session
- * snapshot layer (backend/shared/system-prompt.ts) calls this with the
+ * snapshot layer (backend/runtime/prompt/system-prompt.ts) calls this with the
  * chat's owning frontend and freezes the result per session.
  */
 export function buildSystemPromptPartsFor(