@vellumai/assistant 0.8.11 → 0.8.12-staging.1

package/src/cli/lib/upgrade-plugin.ts

@@ -0,0 +1,219 @@
+/**
+ * Upgrade a single installed plugin to the marketplace's current pin.
+ *
+ * The marketplace pins every plugin to a full, immutable commit SHA (see
+ * {@link ./plugin-marketplace}); an upgrade re-materializes the install at
+ * whatever SHA the catalog currently advertises. Drift is detected with the
+ * same exact commit-SHA comparison {@link ./inspect-plugin} uses, so an
+ * upgrade is a no-op when the installed copy already matches the pin.
+ *
+ * This is deliberately a distinct operation from install: `install` is
+ * first-time materialization (and errors on an existing install unless
+ * `--force` is passed), whereas `upgrade` moves an existing install forward.
+ * Mechanically the move is a forced re-install at the current pin, which the
+ * underlying {@link ./install-from-github.installPlugin} performs atomically —
+ * the previously installed copy is preserved until the fetch succeeds.
+ *
+ * Conflict resolution for locally-modified plugins is intentionally out of
+ * scope here: this overwrites the install with the pinned tree. A future
+ * iteration will detect local edits (installed SHA = merge base) and resolve
+ * them before the swap.
+ *
+ * Designed for direct programmatic use with injected dependencies, mirroring
+ * the sibling plugin libraries. The CLI command `assistant plugins upgrade
+ * <name>` is a thin wrapper that supplies production deps and formats the
+ * result.
+ */
+
+import { join } from "node:path";
+
+import { getWorkspacePluginsDir } from "../../util/platform.js";
+import {
+  inspectPlugin,
+  type PluginInspection,
+  PluginInspectNotFoundError,
+} from "./inspect-plugin.js";
+import {
+  type FetchLike,
+  type GitRunner,
+  installPlugin,
+  type PostinstallRunner,
+  sanitizePluginName,
+} from "./install-from-github.js";
+import { PluginNotInstalledError } from "./uninstall-plugin.js";
+
+/**
+ * Outcome of an upgrade attempt.
+ *
+ * - `upgraded` — the install was moved to the current marketplace pin.
+ * - `already-up-to-date` — the installed commit already equals the pin; no-op.
+ * - `would-upgrade` — a `--dry-run` that found drift but made no changes.
+ */
+export type PluginUpgradeOutcome =
+  | "upgraded"
+  | "already-up-to-date"
+  | "would-upgrade";
+
+/** Options that control which plugin to upgrade and how. */
+export interface UpgradePluginOptions {
+  /** Install name (kebab-case directory name). */
+  readonly name: string;
+  /** Report what would change without modifying the install. */
+  readonly dryRun?: boolean;
+}
+
+/** Dependencies injected by the caller. */
+export interface UpgradePluginDeps {
+  /** HTTP client. Production callers pass `globalThis.fetch.bind(globalThis)`. */
+  readonly fetch: FetchLike;
+  /** Override the workspace plugins directory. Falls back to the live workspace. */
+  readonly workspacePluginsDir?: string;
+  /** Override the git runner used to clone the source. Forwarded to {@link installPlugin}. */
+  readonly runGit?: GitRunner;
+  /** Override the postinstall adapter runner. Forwarded to {@link installPlugin}. */
+  readonly runPostinstall?: PostinstallRunner;
+}
+
+/** Result of an upgrade attempt. */
+export interface PluginUpgradeResult {
+  readonly name: string;
+  readonly outcome: PluginUpgradeOutcome;
+  /** Installed commit before the upgrade; `null` when no provenance was recorded. */
+  readonly fromCommit: string | null;
+  /** Marketplace-pinned commit the install was (or would be) moved to. */
+  readonly toCommit: string;
+  /** Absolute path to the installed plugin directory. */
+  readonly target: string;
+  /** Files materialized by the upgrade; `null` for a no-op or dry run. */
+  readonly fileCount: number | null;
+  /** Whether this was a dry run (no changes made). */
+  readonly dryRun: boolean;
+  /**
+   * Whether the installed copy lacked resolvable provenance before the
+   * upgrade. Such installs are re-pinned to the current SHA, which also
+   * records provenance going forward.
+   */
+  readonly provenanceWasUnknown: boolean;
+}
+
+/** An installed plugin has no marketplace pin to upgrade to. */
+export class PluginNotUpgradableError extends Error {
+  constructor(
+    readonly pluginName: string,
+    reason: string,
+  ) {
+    super(`Plugin "${pluginName}" cannot be upgraded: ${reason}.`);
+    this.name = "PluginNotUpgradableError";
+  }
+}
+
+function pluginTarget(name: string, deps: UpgradePluginDeps): string {
+  const dir = deps.workspacePluginsDir ?? getWorkspacePluginsDir();
+  return join(dir, name);
+}
+
+/**
+ * Move an installed plugin to the marketplace's current pin.
+ *
+ * Throws {@link PluginNotInstalledError} when no copy is installed,
+ * {@link PluginNotUpgradableError} when the install has no marketplace pin to
+ * advance to (no catalog entry, or the catalog was unreachable), and
+ * propagates {@link installPlugin}'s errors (e.g. source unavailable,
+ * postinstall failure) when the re-install itself fails.
+ */
+export async function upgradePlugin(
+  opts: UpgradePluginOptions,
+  deps: UpgradePluginDeps,
+): Promise<PluginUpgradeResult> {
+  const name = sanitizePluginName(opts.name);
+  const dryRun = opts.dryRun ?? false;
+
+  let inspection: PluginInspection;
+  try {
+    inspection = await inspectPlugin(
+      { name },
+      { fetch: deps.fetch, workspacePluginsDir: deps.workspacePluginsDir },
+    );
+  } catch (err) {
+    if (err instanceof PluginInspectNotFoundError) {
+      throw new PluginNotInstalledError(name, pluginTarget(name, deps));
+    }
+    throw err;
+  }
+
+  switch (inspection.status) {
+    case "not-installed":
+      throw new PluginNotInstalledError(name, pluginTarget(name, deps));
+    case "not-in-marketplace":
+      throw new PluginNotUpgradableError(
+        name,
+        "it has no marketplace entry to upgrade from",
+      );
+    case "remote-unavailable":
+      throw new PluginNotUpgradableError(
+        name,
+        `the marketplace could not be reached (${inspection.remoteError ?? "unknown error"})`,
+      );
+  }
+
+  // The remaining statuses (up-to-date, update-available, unknown-provenance)
+  // all imply an installed copy and a resolvable marketplace pin.
+  const { local, remote } = inspection;
+  if (!local || !remote) {
+    throw new PluginNotUpgradableError(
+      name,
+      "its install or marketplace metadata could not be resolved",
+    );
+  }
+
+  const fromCommit = local.commit;
+  const toCommit = remote.commit;
+  const provenanceWasUnknown = inspection.status === "unknown-provenance";
+
+  if (inspection.status === "up-to-date") {
+    return {
+      name,
+      outcome: "already-up-to-date",
+      fromCommit,
+      toCommit,
+      target: local.target,
+      fileCount: null,
+      dryRun,
+      provenanceWasUnknown: false,
+    };
+  }
+
+  if (dryRun) {
+    return {
+      name,
+      outcome: "would-upgrade",
+      fromCommit,
+      toCommit,
+      target: local.target,
+      fileCount: null,
+      dryRun: true,
+      provenanceWasUnknown,
+    };
+  }
+
+  const result = await installPlugin(
+    { name, force: true },
+    {
+      fetch: deps.fetch,
+      workspacePluginsDir: deps.workspacePluginsDir,
+      runGit: deps.runGit,
+      runPostinstall: deps.runPostinstall,
+    },
+  );
+
+  return {
+    name,
+    outcome: "upgraded",
+    fromCommit,
+    toCommit: result.commit ?? toCommit,
+    target: result.target,
+    fileCount: result.fileCount,
+    dryRun: false,
+    provenanceWasUnknown,
+  };
+}

package/src/config/bundled-skills/subagent/SKILL.md

@@ -39,6 +39,7 @@ Each subagent is spawned with a role that determines its tool access. Choose the
 | `researcher` | `web_search`, `web_fetch`, `file_read`, `file_list`, `recall`, `notify_parent` | Information gathering, web research, codebase exploration, reading documentation |
 | `coder` | `bash`, `file_read`, `file_write`, `file_edit`, `web_search`, `recall`, `notify_parent` | Code changes, file editing, running commands, build/test tasks |
 | `planner` | `file_read`, `file_list`, `web_search`, `web_fetch`, `recall`, `notify_parent` | Analysis, planning, synthesizing information, reviewing approaches |
+| `investigator` | `bash`, `file_read`, `file_list`, `web_search`, `web_fetch`, `recall`, `notify_parent` | Root-cause analysis: debugging, log forensics, tracing behavior across many files. Shell access is for read-only investigation (grep/find/reading logs); returns a compact root-cause report |
 
 All specialized roles (`researcher`, `coder`, `planner`) include `notify_parent` for mid-run communication with the parent.
 
@@ -97,5 +98,6 @@ Rule of thumb: "Does this task need to know what we've been talking about?" If y
 - Use `subagent_message` to send follow-up instructions to a running subagent.
 - Use `subagent_abort` to cancel a subagent that is no longer needed.
 - Default to spawning subagents for any task that involves web research, multi-file exploration, or independent coding work. Serial execution should be the exception, not the rule.
+- Delegate root-cause investigations ("why is X happening?", debugging, log forensics) to an `investigator` instead of grepping inline. A long investigation done inline floods your own context with file slices and grep output, crowding out the conversation; the investigator does the digging in its own context and returns a compact root-cause report.
 - When a user request has both an information-gathering component and an action component, spawn a researcher immediately rather than doing the research inline yourself.
 - Prefer spawning 2-3 focused subagents over one large general-purpose subagent. Smaller scopes finish faster and fail more gracefully.

package/src/config/bundled-skills/subagent/TOOLS.json

@@ -31,8 +31,14 @@
           },
           "role": {
             "type": "string",
-            "enum": ["general", "researcher", "coder", "planner"],
-            "description": "Agent specialization that controls tool access. 'researcher': read-only (web, files, memory). 'coder': file and bash access. 'planner': read-only analysis. 'general': full access (default). Ignored when fork: true (forks always use general)."
+            "enum": [
+              "general",
+              "researcher",
+              "coder",
+              "planner",
+              "investigator"
+            ],
+            "description": "Agent specialization that controls tool access. 'researcher': read-only (web, files, memory). 'coder': file and bash access. 'planner': read-only analysis. 'investigator': root-cause analysis — debugging, log forensics, tracing behavior across many files; has bash for read-only investigation (grep/find/log inspection) and returns a compact root-cause report. 'general': full access (default). Ignored when fork: true (forks always use general)."
           }
         },
         "required": ["label", "objective"]

package/src/config/call-site-defaults.ts

@@ -7,6 +7,13 @@ type CallSiteDefaultConfig = {
   temperature?: number | null;
   thinking?: { enabled?: boolean; streamThinking?: boolean };
   contextWindow?: { maxInputTokens?: number };
+  /**
+   * Opt the call site out of prompt caching. Set for one-shot call sites
+   * whose prompts never repeat — or repeat slower than the cache TTL — so
+   * each call would pay the cache-write premium without a future read.
+   * Telemetry confirms ~0–5% cache hit rates on these sites.
+   */
+  disableCache?: boolean;
 };
 
 export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
@@ -17,7 +24,7 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
   patternScan: { profile: "balanced" },
   narrativeRefinement: { profile: "balanced" },
   callAgent: { profile: "balanced" },
-  memoryConsolidation: { profile: "balanced" },
+  memoryConsolidation: { profile: "balanced", disableCache: true },
   identityIntro: { profile: "balanced" },
   emptyStateGreeting: { profile: "balanced" },
 
@@ -32,6 +39,7 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
     effort: "low",
     thinking: { enabled: false, streamThinking: false },
     temperature: 0,
+    disableCache: true,
   },
   conversationStarters: {
     profile: "balanced",
@@ -47,7 +55,7 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
   memoryV2Sweep: { profile: "cost-optimized" },
   memoryV2Consolidation: { profile: "balanced" },
   conversationSummarization: { profile: "cost-optimized" },
-  conversationTitle: { profile: "cost-optimized" },
+  conversationTitle: { profile: "cost-optimized", disableCache: true },
   approvalCopy: { profile: "cost-optimized" },
   approvalConversation: { profile: "cost-optimized" },
   trustRuleSuggestion: { profile: "cost-optimized" },
@@ -70,6 +78,7 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
     profile: "cost-optimized",
     effort: "low",
     thinking: { enabled: false },
+    disableCache: true,
   },
   guardianQuestionCopy: {
     profile: "cost-optimized",
@@ -107,11 +116,13 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
     effort: "low",
     thinking: { enabled: false },
     temperature: 0.7,
+    disableCache: true,
   },
   homeSuggestedPrompts: {
     profile: "cost-optimized",
     maxTokens: 512,
     effort: "low",
     thinking: { enabled: false },
+    disableCache: true,
   },
 };

package/src/config/feature-flag-registry.json

@@ -75,14 +75,6 @@
       "description": "Control Developer nav visibility in macOS settings",
       "defaultEnabled": false
     },
-    {
-      "id": "system-schedule-toggles",
-      "scope": "assistant",
-      "key": "system-schedule-toggles",
-      "label": "System Schedule Toggles",
-      "description": "Show the Heartbeat pause toggle on the schedules settings page. The toggle only pauses automatic runs; manual Run now remains available.",
-      "defaultEnabled": false
-    },
     {
       "id": "developer-menu-items",
       "scope": "client",
@@ -363,6 +355,14 @@
       "description": "Enable self-hosted assistant configuration.",
       "defaultEnabled": false
     },
+    {
+      "id": "web-remote-ingress",
+      "scope": "assistant",
+      "key": "web-remote-ingress",
+      "label": "Web Remote Ingress",
+      "description": "Serve the web client over a public tunnel and enable browser pairing for self-hosted assistants.",
+      "defaultEnabled": false
+    },
     {
       "id": "settings-sleep-policy",
       "scope": "assistant",
@@ -403,14 +403,6 @@
       "description": "When on, memory-v3 topic-tree retrieval becomes the live injected memory source (suppressing v2 injection). Off by default; only enable after shadow telemetry validates the design.",
       "defaultEnabled": false
     },
-    {
-      "id": "empty-state-dynamic-greetings",
-      "scope": "assistant",
-      "key": "empty-state-dynamic-greetings",
-      "label": "Dynamic Empty-State Greetings",
-      "description": "Enable the empty new-chat screen to refresh cached greeting options via the empty-state greeting LLM call site. When off, the assistant serves workspace-authored greetings or static fallbacks only.",
-      "defaultEnabled": false
-    },
     {
       "id": "self-intro-greeting",
       "scope": "both",

package/src/config/loader.ts

@@ -5,14 +5,14 @@ import {
   renameSync,
   writeFileSync,
 } from "node:fs";
-import { basename, dirname, join } from "node:path";
+import { dirname, join } from "node:path";
 
 import { safeStatSync } from "../util/fs.js";
 import { getLogger } from "../util/logger.js";
 import {
   ensureDataDir,
+  getConfigQuarantineNoticePath,
   getWorkspaceConfigPath,
-  getWorkspaceDir,
 } from "../util/platform.js";
 import { AssistantConfigSchema } from "./schema.js";
 import type { AssistantConfig } from "./types.js";
@@ -201,10 +201,9 @@ function filesystemSafeTimestamp(date: Date = new Date()): string {
  * in `.json` so editors syntax-highlight the preserved content:
  *   `<path>.corrupt-<ISO-timestamp>.json`
  *
- * On a successful rename, also appends a bulletin to `<workspace>/UPDATES.md`
- * so the background update-bulletin job surfaces the event to the user
- * proactively on their next interaction (log-level errors alone are invisible
- * to users).
+ * On a successful rename, also writes a small JSON sentinel recording the
+ * event so the per-turn `config-quarantine-notice` injector can surface it to
+ * the agent (log-level errors alone are invisible to users).
  */
 function quarantineCorruptConfig(configPath: string, err: unknown): string {
   const quarantinePath = `${configPath}.corrupt-${filesystemSafeTimestamp()}.json`;
@@ -215,7 +214,7 @@ function quarantineCorruptConfig(configPath: string, err: unknown): string {
         `quarantined to ${quarantinePath} and loaded defaults. ` +
         `Inspect the quarantined file to recover any hand-edited settings.`,
     );
-    appendQuarantineBulletin(configPath, quarantinePath);
+    writeQuarantineNotice(configPath, quarantinePath);
   } catch (renameErr) {
     log.error(
       { renameErr },
@@ -227,66 +226,55 @@ function quarantineCorruptConfig(configPath: string, err: unknown): string {
 }
 
 /**
- * Append a config-quarantine bulletin to `<workspace>/UPDATES.md`. On the
- * next daemon boot the background update-bulletin job picks up UPDATES.md
- * and processes it inside a background-only conversation (not the user's
- * chat). The agent decides whether and when to surface the event — typical
- * cases are the user asking why their settings changed or noticing missing
- * API keys. The bulletin is agent-visible context, not a push notification.
+ * Write a small JSON sentinel recording that the config file was quarantined.
+ * The per-turn `config-quarantine-notice` injector reads this sentinel and, if
+ * it is recent, injects a system block so the agent can explain the reset when
+ * the user asks why their settings changed or notices missing API keys.
  *
- * Idempotency: the appended block embeds a marker keyed on the quarantine
- * filename's basename. If that marker is already present in UPDATES.md (a
- * prior append succeeded but the process crashed before control returned, or
- * the file was hand-edited), the function is a no-op. This mirrors the
- * pattern release-notes workspace migrations use — see the "Release Update
- * Hygiene" section in the root `AGENTS.md`.
+ * Writes with pure `node:fs` and a workspace-derived path
+ * ({@link getConfigQuarantineNoticePath}) deliberately: config load happens
+ * extremely early at daemon startup — before the SQLite DB is initialized and
+ * before `getConfig().dataDir` is available — so neither a DB checkpoint nor a
+ * config-dependent path can be used here without risking import-time DB init.
+ *
+ * Idempotent per quarantine event: each call overwrites the sentinel with the
+ * latest event, so a crash-then-retry re-records the same (or newer) event
+ * rather than accumulating duplicates.
  *
  * Best-effort: any write failure is logged at `warn` and swallowed. The
  * quarantine path must never block startup, and the error log from
  * `quarantineCorruptConfig` remains the authoritative record.
  *
- * Exported with an underscore-prefixed alias (`_appendQuarantineBulletin`) so
- * tests can exercise the idempotent-skip branch directly with a deterministic
- * quarantine basename. Non-test callers should never import the underscore
- * alias — the wiring into `quarantineCorruptConfig` is the production entry
- * point.
+ * Exported with an underscore-prefixed alias (`_writeQuarantineNotice`) so
+ * tests can exercise the write directly. Non-test callers should never import
+ * the underscore alias — the wiring into `quarantineCorruptConfig` is the
+ * production entry point.
  */
-function appendQuarantineBulletin(
+function writeQuarantineNotice(
   originalPath: string,
   quarantinePath: string,
 ): void {
   try {
-    const updatesPath = join(getWorkspaceDir(), "UPDATES.md");
-    const quarantineBasename = basename(quarantinePath);
-    const marker = `<!-- config-quarantine:${quarantineBasename} -->`;
-
-    const existing = existsSync(updatesPath)
-      ? readFileSync(updatesPath, "utf-8")
-      : "";
-    if (existing.includes(marker)) return;
-
-    const timestamp = new Date().toISOString();
-    const block =
-      `## Config was reset to defaults\n\n` +
-      `Your \`config.json\` was unreadable at ${timestamp} and couldn't be parsed ` +
-      `as JSON. The assistant preserved the original file at \`${quarantinePath}\` ` +
-      `and loaded defaults so the app stays working.\n\n` +
-      `If you had custom settings (API keys, model choices, voice preferences), ` +
-      `they are still in the quarantined file — \`cat ${quarantinePath}\` to ` +
-      `recover them, then re-enter through Settings or the CLI.\n\n` +
-      `${marker}\n`;
-
-    const toWrite = existing.length === 0 ? block : `${existing}\n${block}`;
-    writeFileSync(updatesPath, toWrite, "utf-8");
+    const noticePath = getConfigQuarantineNoticePath();
+    const dir = dirname(noticePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    const notice = {
+      quarantinedAt: new Date().toISOString(),
+      quarantinePath,
+      originalPath,
+    };
+    writeFileSync(noticePath, JSON.stringify(notice, null, 2) + "\n", "utf-8");
     log.info(
-      `Appended config-quarantine bulletin to ${updatesPath} for ${originalPath} ` +
-        `(quarantined as ${quarantineBasename}).`,
+      `Wrote config-quarantine notice to ${noticePath} for ${originalPath} ` +
+        `(quarantined as ${quarantinePath}).`,
     );
-  } catch (bulletinErr) {
+  } catch (noticeErr) {
     log.warn(
-      { bulletinErr },
-      `Failed to append config-quarantine bulletin to UPDATES.md; ` +
-        `the quarantine event is still recorded in the assistant logs.`,
+      { noticeErr },
+      `Failed to write config-quarantine notice; the quarantine event is ` +
+        `still recorded in the assistant logs.`,
     );
   }
 }
@@ -660,7 +648,9 @@ export function loadConfig(): AssistantConfig {
           quarantineCorruptConfig(
             configPath,
             new Error(
-              `config.json must contain a JSON object at the top level; got ${describeJsonShape(parsed)}`,
+              `config.json must contain a JSON object at the top level; got ${describeJsonShape(
+                parsed,
+              )}`,
             ),
           );
           fileConfig = {};
@@ -889,7 +879,9 @@ export function loadRawConfig(): Record<string, unknown> {
     quarantineCorruptConfig(
       configPath,
       new Error(
-        `config.json must contain a JSON object at the top level; got ${describeJsonShape(parsed)}`,
+        `config.json must contain a JSON object at the top level; got ${describeJsonShape(
+          parsed,
+        )}`,
       ),
     );
     return {};
@@ -963,8 +955,9 @@ export function setNestedValue(
 }
 
 /**
- * Test-only alias for `appendQuarantineBulletin`. Exists so the crash-mid-
- * append idempotency branch can be exercised with a deterministic quarantine
- * basename without widening the runtime surface. Not for production use.
+ * Test-only alias for `writeQuarantineNotice`. Exists so the sentinel write
+ * (and its overwrite/idempotency semantics) can be exercised directly with a
+ * deterministic quarantine path without widening the runtime surface. Not for
+ * production use.
  */
-export const _appendQuarantineBulletin = appendQuarantineBulletin;
+export const _writeQuarantineNotice = writeQuarantineNotice;

package/src/config/schema.ts

@@ -56,7 +56,6 @@ import {
   TimeoutConfigSchema,
 } from "./schemas/timeouts.js";
 import { ToolsConfigSchema } from "./schemas/tools.js";
-import { UpdatesConfigSchema } from "./schemas/updates.js";
 import { WorkspaceGitConfigSchema } from "./schemas/workspace-git.js";
 
 export const AssistantConfigSchema = z
@@ -89,7 +88,6 @@ export const AssistantConfigSchema = z
     llmRequestLogs: LlmRequestLogsConfigSchema,
     filing: FilingConfigSchema.default(FilingConfigSchema.parse({})),
     heartbeat: HeartbeatConfigSchema.default(HeartbeatConfigSchema.parse({})),
-    updates: UpdatesConfigSchema.default(UpdatesConfigSchema.parse({})),
     hostBrowser: HostBrowserConfigSchema.default(
       HostBrowserConfigSchema.parse({}),
     ),

package/src/config/schemas/__tests__/memory-v2.test.ts

@@ -24,6 +24,7 @@ describe("MemoryV2ConfigSchema", () => {
       bm25_b: 0.4,
       consolidation_interval_hours: 4,
       consolidation_max_buffer_lines: 100,
+      consolidation_max_entries_per_run: 150,
       max_page_chars: 5000,
       consolidation_prompt_path: null,
       rerank: {

package/src/config/schemas/__tests__/memory-v3.test.ts

@@ -8,9 +8,19 @@ describe("MemoryV3ConfigSchema", () => {
     expect(parsed).toEqual({
       prune: { maxResidentBytes: 393216, targetResidentBytes: 262144 },
       hotSet: { k: 40, halfLifeDays: 14 },
+      freshSet: { k: 100 },
+      learnedEdges: {
+        halfLifeDays: 30,
+        minCount: 3,
+        npmiFloor: 0.2,
+        maxPerPage: 6,
+        perSeed: 3,
+        cap: 20,
+      },
       spotlight: { n: 6, windowTurns: 2 },
       needleK: 100,
       denseK: 100,
+      replyQueryK: 12,
       edge: { hubDegree: 30, seedCount: 18, perSeed: 6, cap: 45 },
     });
   });

package/src/config/schemas/llm.ts

@@ -331,6 +331,15 @@ export const LLMConfigBase = z.object({
   // `profileConfigFragment`, which strips it from the merge), so a preset
   // can't bleed from a lower-precedence profile into one that didn't opt in.
   logitBias: LogitBiasPresetSchema.optional(),
+  /**
+   * Opt this config out of prompt caching. Providers send no cache
+   * breakpoints and strip caller-stamped `cache_control` markers. Intended
+   * for one-shot call sites whose prompts never repeat (or repeat slower
+   * than the cache TTL), where every breakpoint is a paid cache write with
+   * no future read. Optional (no schema default) so it only appears in
+   * resolved configs when a layer sets it.
+   */
+  disableCache: z.boolean().optional(),
 });
 export type LLMConfigBase = z.infer<typeof LLMConfigBase>;
 
@@ -352,6 +361,7 @@ const LLMConfigFragment = z.object({
   contextWindow: ContextWindowDeepPartialSchema.optional(),
   openrouter: OpenRouterDeepPartialSchema.optional(),
   logitBias: LogitBiasPresetSchema.optional(),
+  disableCache: z.boolean().optional(),
 });
 type LLMConfigFragment = z.infer<typeof LLMConfigFragment>;
 

package/src/config/schemas/memory-v2.ts

@@ -207,6 +207,19 @@ export const MemoryV2ConfigSchema = z
       .describe(
         "Size-based trigger for consolidation. When `memory/buffer.md` reaches this many non-empty lines, consolidation runs even if the time-based interval hasn't elapsed. Defaults to 100. Set to `null` to disable the size trigger and rely solely on `consolidation_interval_hours`.",
       ),
+    consolidation_max_entries_per_run: z
+      .number({
+        error: "memory.v2.consolidation_max_entries_per_run must be a number",
+      })
+      .int("memory.v2.consolidation_max_entries_per_run must be an integer")
+      .positive(
+        "memory.v2.consolidation_max_entries_per_run must be a positive integer",
+      )
+      .nullable()
+      .default(150)
+      .describe(
+        "Upper bound on buffer entries one consolidation run may process. When the buffer holds more, the run's cutoff is moved back to the first over-cap entry's timestamp so the overflow is deferred to a follow-up pass (the `consolidation_max_buffer_lines` size trigger re-fires while the remainder stays over threshold). Bounds the context a single agentic run must read after a backlog. Set to `null` to always process the full buffer.",
+      ),
     max_page_chars: z
       .number({ error: "memory.v2.max_page_chars must be a number" })
       .int("memory.v2.max_page_chars must be an integer")