@vellumai/assistant 0.8.9-staging.3 → 0.8.9-staging.4

package/src/daemon/conversation-agent-loop.ts

@@ -33,7 +33,6 @@ import {
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import type { ContextWindowConfig } from "../config/types.js";
-import { runEmergencyCompaction } from "../context/compactor.js";
 import {
   derefToolResultReReads,
   postTurnTruncateToolResults,
@@ -1221,22 +1220,15 @@ export async function runAgentLoopImpl(
       // compressing history. Falls through to reducer tiers on failure.
       {
         try {
-          const emergencyConfig = getConfig().compaction;
-          const emergencyResult = await runEmergencyCompaction({
-            conversationId: ctx.conversationId,
-            messages: ctx.messages,
-            provider: ctx.provider,
-            systemPrompt: ctx.systemPrompt,
-            tools: undefined,
-            compaction: emergencyConfig,
-            maxInputTokens: resolveCurrentMaxInputTokens(),
-            previousEstimatedInputTokens: estimatedTokensAtOverflow,
-            force: true,
-            signal: abortController.signal,
-            overrideProfile: resolveCurrentOverrideProfile() ?? null,
-            nonPersistedPrefixCount:
-              ctx.contextWindowManager.nonPersistedPrefixCount,
-          });
+          const emergencyResult =
+            await ctx.contextWindowManager.emergencyCompact(
+              ctx.messages,
+              {
+                previousEstimatedInputTokens: estimatedTokensAtOverflow,
+                overrideProfile: resolveCurrentOverrideProfile() ?? null,
+              },
+              abortController.signal,
+            );
           if (emergencyResult.compacted) {
             rlog.info(
               {

package/src/daemon/external-plugins-bootstrap.ts

@@ -65,6 +65,7 @@ import { getConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/schema.js";
 import { HOOKS } from "../plugin-api/constants.js";
 import { registerDefaultPlugins } from "../plugins/defaults/index.js";
+import { installPluginRuntime } from "../plugins/external-api.js";
 import { buildExternalPlugin } from "../plugins/external-plugin-loader.js";
 import {
   registerPluginSkills,
@@ -186,17 +187,21 @@ function getDisabledPluginFlag(
  * Bring the plugin layer up during daemon startup. Runs the full sequence in
  * the one order the rest of the system depends on:
  *
- * 1. Register the first-party defaults so their middleware composes innermost,
+ * 1. Install the `globalThis.__vellumPluginRuntime` bridge so plugins can touch
+ *    it from their module body (see `plugins/external-api.ts` — compiled-binary
+ *    module identity).
+ * 2. Register the first-party defaults so their middleware composes innermost,
  *    ahead of any user plugins.
- * 2. Load user plugins from `<workspaceDir>/plugins/*`. A failing user plugin is
+ * 3. Load user plugins from `<workspaceDir>/plugins/*`. A failing user plugin is
  *    logged and skipped; `loadUserPlugins()` closes the registration window
  *    when it returns, so the defaults must already be registered by then.
- * 3. Run every registered plugin's `init()` via {@link bootstrapPlugins}.
+ * 4. Run every registered plugin's `init()` via {@link bootstrapPlugins}.
  *
  * Plugin bootstrap is wrapped so a failing plugin cannot block daemon startup —
  * the daemon comes up with degraded plugin functionality instead.
  */
 export async function initializePlugins(): Promise<void> {
+  installPluginRuntime();
   registerDefaultPlugins();
   await loadUserPlugins();
   try {

package/src/daemon/tool-side-effects.ts

@@ -155,6 +155,21 @@ registerHook("app_refresh", (_name, input, _result, { ctx }) => {
   notifyAppChanged(ctx, appId, { fileChange: true });
 });
 
+// app_update compiles internally (like app_refresh) but emits no events of its
+// own, so without this hook an updated app leaves open surfaces rendering the
+// stale dist and never re-deploys or invalidates the Library. The executor owns
+// the compile; notifyAppChanged only refreshes surfaces and broadcasts.
+registerHook("app_update", (_name, input, _result, { ctx }) => {
+  const appId = input.app_id as string | undefined;
+  if (!appId) return;
+  try {
+    addAppConversationId(appId, ctx.conversationId);
+  } catch (err) {
+    log.warn({ err, appId }, "Failed to track conversation ID on app_update");
+  }
+  notifyAppChanged(ctx, appId, { fileChange: true });
+});
+
 registerHook("voice_config_update", (_name, input) => {
   const setting = input.setting as string | undefined;
   if (!setting) return;

package/src/memory/v2/__tests__/consolidation-job.test.ts

@@ -105,43 +105,15 @@ mock.module("../../jobs-store.js", () => ({
   isMemoryEnabled: () => true,
 }));
 
-// ── v3 health-injection mocks ───────────────────────────────────────
+// ── v3 follow-up flag mock ──────────────────────────────────────────
 //
-// The consolidation handler optionally prepends a v3 health block to the
-// prompt when a v3 flag is on AND the rendered report is non-empty. These
-// mocks let each test (a) toggle the flag, (b) decide what health block the
-// renderer produces, and (c) force the health computation to throw — without
-// materializing a real v3 data dir. The tree/core/page-index loaders are
-// stubbed to inert values; `computeV3Health` is a pass-through whose result is
-// fed to the toggleable `renderV3Health`.
+// A v3 flag being on appends `memory_v3_maintain` to the post-consolidation
+// follow-up fan-out. This mock lets each test toggle the flag.
 let v3FlagOn = false;
 mock.module("../../../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: () => v3FlagOn,
 }));
 
-let renderedHealth = "";
-let computeThrows = false;
-mock.module("../../../plugins/defaults/memory-v3-shadow/health.js", () => ({
-  computeV3Health: () => {
-    if (computeThrows) throw new Error("simulated health compute failure");
-    return {};
-  },
-  renderV3Health: () => renderedHealth,
-}));
-
-mock.module("../../../plugins/defaults/memory-v3-shadow/tree.js", () => ({
-  loadLeafTree: async () => ({ leaves: new Map(), byPage: new Map() }),
-  resolveDataDir: () => "/tmp/v3-data-stub",
-}));
-
-mock.module("../../../plugins/defaults/memory-v3-shadow/core.js", () => ({
-  loadCore: async () => new Set<string>(),
-}));
-
-mock.module("../../v2/page-index.js", () => ({
-  getPageIndex: async () => ({ entries: [] }),
-}));
-
 // ── Workspace pin ───────────────────────────────────────────────────
 let tmpWorkspace: string;
 let previousWorkspaceEnv: string | undefined;
@@ -211,10 +183,8 @@ beforeEach(() => {
   enqueuedJobs.length = 0;
   nextJobIdCounter = 0;
 
-  // v3 health injection defaults: flag off, no rendered block, no throw.
+  // v3 follow-up flag default: off.
   v3FlagOn = false;
-  renderedHealth = "";
-  computeThrows = false;
 });
 
 // ---------------------------------------------------------------------------
@@ -409,69 +379,6 @@ describe("memoryV2ConsolidateJob — non-empty buffer", () => {
   });
 });
 
-describe("memoryV2ConsolidateJob — v3 health injection", () => {
-  beforeEach(() => {
-    writeFileSync(
-      bufferPath(),
-      "- [Apr 27, 9:00 AM] Alice prefers VS Code over Vim.\n",
-    );
-  });
-
-  test("prepends the health block when a v3 flag is on and the report is actionable", async () => {
-    v3FlagOn = true;
-    renderedHealth = "memory-v3 health:\n- 2 unassigned slug(s): a, b";
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    const prompt = runnerLastArgs?.prompt as string;
-    // The health block is PREPENDED, separated by a blank line, with the
-    // base consolidation prompt still present underneath it.
-    expect(prompt.startsWith(`${renderedHealth}\n\n`)).toBe(true);
-    expect(prompt).toContain("memory consolidation");
-    expect(prompt).not.toContain(CUTOFF_PLACEHOLDER);
-  });
-
-  test("leaves the prompt unchanged when the report is all-green (empty render)", async () => {
-    v3FlagOn = true;
-    renderedHealth = "";
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    const prompt = runnerLastArgs?.prompt as string;
-    expect(prompt).not.toContain("memory-v3 health:");
-    // Prompt is exactly the resolved consolidation body.
-    expect(prompt).toContain("memory consolidation");
-  });
-
-  test("leaves the prompt unchanged when v3 flags are off even if a block would render", async () => {
-    v3FlagOn = false;
-    renderedHealth = "memory-v3 health:\n- 1 unassigned slug(s): a";
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    const prompt = runnerLastArgs?.prompt as string;
-    expect(prompt).not.toContain("memory-v3 health:");
-    expect(prompt).toContain("memory consolidation");
-  });
-
-  test("falls back to the base prompt when health computation throws", async () => {
-    v3FlagOn = true;
-    computeThrows = true;
-    renderedHealth = "memory-v3 health:\n- should not appear";
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    // A health-compute failure must NEVER break consolidation.
-    expect(result.kind).toBe("invoked");
-    const prompt = runnerLastArgs?.prompt as string;
-    expect(prompt).not.toContain("memory-v3 health:");
-    expect(prompt).toContain("memory consolidation");
-  });
-});
-
 describe("memoryV2ConsolidateJob — concurrent invocations", () => {
   beforeEach(() => {
     writeFileSync(bufferPath(), "- [Apr 27, 9:00 AM] Alice prefers VS Code.\n");

package/src/memory/v2/__tests__/page-store.test.ts

@@ -186,6 +186,28 @@ describe("writePage + readPage round-trip", () => {
     expect(read!.body).toBe(page.body);
   });
 
+  test("round-trips authored links: frontmatter (memory-v3 edge lane)", async () => {
+    const page = makePage({
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        ref_urls: [],
+        links: ["bob-handoff — the partner this hands off to"],
+      },
+    });
+    await writePage(workspaceDir, page);
+
+    // A page using the optional `links:` frontmatter must NOT be rejected by the
+    // strict schema (it would otherwise be dropped from memory-v3 entirely), and
+    // the curated links must survive the render → read round-trip so the edge
+    // graph can parse them back from the rendered frontmatter.
+    const read = await readPage(workspaceDir, page.slug);
+    expect(read).not.toBeNull();
+    expect(read!.frontmatter.links).toEqual([
+      "bob-handoff — the partner this hands off to",
+    ]);
+  });
+
   test("renders frontmatter at the top with --- delimiters", async () => {
     const page = makePage();
     await writePage(workspaceDir, page);

package/src/memory/v2/consolidation-job.ts

@@ -63,19 +63,6 @@ import { dirname, join } from "node:path";
 
 import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../../config/types.js";
-import { loadCore } from "../../plugins/defaults/memory-v3-shadow/core.js";
-import {
-  computeV3Health,
-  renderV3Health,
-} from "../../plugins/defaults/memory-v3-shadow/health.js";
-import {
-  loadLeafTree,
-  resolveDataDir,
-} from "../../plugins/defaults/memory-v3-shadow/tree.js";
-import type {
-  LeafPath,
-  Slug,
-} from "../../plugins/defaults/memory-v3-shadow/types.js";
 import { runBackgroundJob } from "../../runtime/background-job-runner.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
@@ -86,7 +73,6 @@ import {
   type MemoryJob,
   type MemoryJobType,
 } from "../jobs-store.js";
-import { getPageIndex } from "../v2/page-index.js";
 import { MEMORY_V2_CONSOLIDATION_SOURCE } from "./constants.js";
 import { resolveConsolidationPrompt } from "./prompts/consolidation.js";
 
@@ -96,8 +82,7 @@ const log = getLogger("memory-v2-consolidate");
 const JOB_NAME = "memory.consolidate";
 
 /**
- * v3 plugin flags. Either being on (a) prepends a v3 health block to the
- * consolidation prompt and (b) enqueues `memory_v3_maintain` as a
+ * v3 plugin flags. Either being on enqueues `memory_v3_maintain` as a
  * post-consolidation follow-up. These gate the v3 plugin itself.
  */
 const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
@@ -191,15 +176,10 @@ export async function memoryV2ConsolidateJob(
     // it to a regular file under 1 MiB before substitution so a stray path
     // (or a `/dev/zero`-style pseudo-file) cannot exfiltrate megabytes of
     // bytes through the wake hint.
-    //
-    // That resolved prompt is the base; `maybePrependV3Health` prepends a
-    // freshly computed v3 health block when a v3 flag is on and the tree has
-    // actionable drift, leaving it untouched otherwise.
-    const basePrompt = resolveConsolidationPrompt(
+    const prompt = resolveConsolidationPrompt(
       config.memory.v2.consolidation_prompt_path,
       cutoff,
     );
-    const prompt = await maybePrependV3Health(basePrompt, config);
 
     const runResult = await runBackgroundJob({
       jobName: JOB_NAME,
@@ -270,56 +250,6 @@ export async function memoryV2ConsolidateJob(
   }
 }
 
-/**
- * When a v3 flag is enabled and the v3 tree has actionable structural drift,
- * prepend a rendered health block to `basePrompt` so the consolidation run can
- * fold tree maintenance into its pass. Returns `basePrompt` UNCHANGED when:
- *   - neither `memory-v3-shadow` nor `memory-v3-live` is enabled,
- *   - the health report is all-green (`renderV3Health` returns ""), or
- *   - computing the report throws for any reason.
- *
- * The block is computed here (not baked into the prompt template) so an
- * operator's custom consolidation prompt stays untouched and the block reflects
- * the tree state at run time. Health computation is wrapped so a load/compute
- * failure can never break consolidation — the run proceeds on the base prompt.
- */
-async function maybePrependV3Health(
-  basePrompt: string,
-  config: AssistantConfig,
-): Promise<string> {
-  const v3Enabled =
-    isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config) ||
-    isAssistantFeatureFlagEnabled(MEMORY_V3_LIVE, config);
-  if (!v3Enabled) return basePrompt;
-
-  try {
-    const pageIndex = await getPageIndex(getWorkspaceDir());
-    const pageLeaves = new Map<Slug, LeafPath[]>();
-    const allSlugs: Slug[] = [];
-    for (const entry of pageIndex.entries) {
-      pageLeaves.set(entry.slug, entry.leaves);
-      allSlugs.push(entry.slug);
-    }
-
-    const dataDir = resolveDataDir();
-    const [tree, core] = await Promise.all([
-      loadLeafTree(dataDir, pageLeaves),
-      loadCore(dataDir),
-    ]);
-
-    const report = computeV3Health({ tree, allSlugs, core });
-    const healthBlock = renderV3Health(report);
-    if (healthBlock.length === 0) return basePrompt;
-    return `${healthBlock}\n\n${basePrompt}`;
-  } catch (err) {
-    log.warn(
-      { err: err instanceof Error ? err.message : String(err) },
-      "consolidation: v3 health computation failed; using base prompt",
-    );
-    return basePrompt;
-  }
-}
-
 /**
  * Read `memory/buffer.md`. Missing file → empty string so the skip-on-empty
  * branch doesn't have to distinguish "no file" from "blank file".

package/src/memory/v2/types.ts

@@ -41,6 +41,11 @@ export const ConceptPageFrontmatterSchema = z
     ref_urls: z.array(z.string().url()).default([]),
     summary: z.string().optional(),
     leaves: z.array(z.string()).optional(),
+    // Optional authored `"<target-slug> — <why>"` cross-links. Curated, first-class
+    // edges for the memory-v3 edge lane. Declared here so `.strict()` does not
+    // reject a page that uses `links:`, and so `renderPageContent` round-trips the
+    // field (the edge graph reads it back from the rendered frontmatter).
+    links: z.array(z.string()).optional(),
   })
   .strict();
 

package/src/plugins/defaults/compaction/window-manager.ts

@@ -20,7 +20,9 @@ import type { LLMCallSite } from "../../../config/schemas/llm.js";
 import type { ContextWindowConfig } from "../../../config/types.js";
 import {
   type CompactionRunArgs,
+  type CompactionRunResult,
   runAssistantDrivenCompaction,
+  runEmergencyCompaction,
 } from "../../../context/compactor.js";
 import { estimatePromptTokens } from "../../../context/token-estimator.js";
 import type {
@@ -118,6 +120,21 @@ export interface ContextWindowCompactOptions {
   actorTrustClass?: TrustClass;
 }
 
+export interface EmergencyCompactOptions {
+  /**
+   * The provider-reported estimate at the overflow that triggered recovery.
+   * Sizing the emergency summary needs the actual rejected token count, not
+   * the manager's pre-send estimate (which under-counted, hence the
+   * rejection).
+   */
+  previousEstimatedInputTokens: number;
+  /**
+   * Per-conversation inference-profile override forwarded to the summary
+   * call.
+   */
+  overrideProfile?: string | null;
+}
+
 export interface ContextWindowManagerOptions {
   provider: Provider;
   systemPrompt: string | (() => string);
@@ -428,6 +445,45 @@ export class ContextWindowManager {
     return { ...result, estimatedInputTokens, exhausted: true };
   }
 
+  /**
+   * Emergency mid-turn compaction — summarize everything before the last
+   * tool_use/tool_result pair and let the agent continue with
+   * `[summary, last_tool_call, last_tool_result]`. Used as a recovery rung
+   * after the provider rejects a turn for context overflow. The manager
+   * supplies the provider, system prompt, token budget, conversation id, and
+   * non-persisted prefix count it already owns; the caller provides only the
+   * overflow-specific inputs.
+   */
+  async emergencyCompact(
+    messages: Message[],
+    options: EmergencyCompactOptions,
+    signal?: AbortSignal,
+  ): Promise<CompactionRunResult> {
+    if (this.conversationId == null) {
+      throw new Error(
+        "ContextWindowManager has no conversationId — cannot run emergency compaction",
+      );
+    }
+    try {
+      return await runEmergencyCompaction({
+        conversationId: this.conversationId,
+        messages,
+        provider: this.provider,
+        systemPrompt: this.systemPrompt,
+        tools: undefined,
+        compaction: this.resolveCompactionConfig(),
+        maxInputTokens: this.config.maxInputTokens,
+        previousEstimatedInputTokens: options.previousEstimatedInputTokens,
+        force: true,
+        signal,
+        overrideProfile: options.overrideProfile ?? null,
+        nonPersistedPrefixCount: this._nonPersistedPrefixCount,
+      });
+    } finally {
+      this.clearSystemPromptCache();
+    }
+  }
+
   /**
    * Recompute the prompt-token estimate against the post-compaction
    * message array. The compactor returns a conservative placeholder; the

package/src/plugins/defaults/memory-v3-shadow/__tests__/capabilities.test.ts

@@ -1,18 +1,11 @@
 import { describe, expect, test } from "bun:test";
 
 import {
-  CAPABILITIES_LEAF_PATH,
+  capabilityOrDiskBody,
   type CapabilityResolvers,
-  injectCapabilitiesLeaf,
   isCapabilitySlug,
   renderCapabilityContent,
 } from "../capabilities.js";
-import { buildNeedleIndex } from "../needle.js";
-import type { LeafPath, LeafTree, Slug } from "../types.js";
-
-function emptyTree(): LeafTree {
-  return { leaves: new Map(), byPage: new Map<Slug, LeafPath[]>() };
-}
 
 describe("isCapabilitySlug", () => {
   test("true for skill and CLI-command slugs, false otherwise", () => {
@@ -23,52 +16,6 @@ describe("isCapabilitySlug", () => {
   });
 });
 
-describe("injectCapabilitiesLeaf", () => {
-  test("registers an always-on leaf with the synthetic slugs as members", () => {
-    const tree = emptyTree();
-    const core = new Set<LeafPath>();
-    injectCapabilitiesLeaf(tree, core, ["skills/foo", "cli-commands/bar"]);
-
-    const leaf = tree.leaves.get(CAPABILITIES_LEAF_PATH);
-    expect(leaf?.frontmatter.in_core).toBe(true);
-    expect(leaf?.members).toEqual(["skills/foo", "cli-commands/bar"]);
-    expect(core.has(CAPABILITIES_LEAF_PATH)).toBe(true);
-  });
-
-  test("unions the leaf into each member's byPage entry without dropping existing leaves", () => {
-    const tree = emptyTree();
-    tree.byPage.set("skills/foo", ["other/leaf"]);
-    injectCapabilitiesLeaf(tree, new Set<LeafPath>(), [
-      "skills/foo",
-      "cli-commands/bar",
-    ]);
-
-    expect(tree.byPage.get("skills/foo")).toEqual([
-      "other/leaf",
-      CAPABILITIES_LEAF_PATH,
-    ]);
-    expect(tree.byPage.get("cli-commands/bar")).toEqual([
-      CAPABILITIES_LEAF_PATH,
-    ]);
-  });
-
-  test("is idempotent — re-injecting does not duplicate the byPage entry", () => {
-    const tree = emptyTree();
-    const core = new Set<LeafPath>();
-    injectCapabilitiesLeaf(tree, core, ["skills/foo"]);
-    injectCapabilitiesLeaf(tree, core, ["skills/foo"]);
-    expect(tree.byPage.get("skills/foo")).toEqual([CAPABILITIES_LEAF_PATH]);
-  });
-
-  test("stays always-on even with no installed skills/commands", () => {
-    const tree = emptyTree();
-    const core = new Set<LeafPath>();
-    injectCapabilitiesLeaf(tree, core, []);
-    expect(tree.leaves.get(CAPABILITIES_LEAF_PATH)?.members).toEqual([]);
-    expect(core.has(CAPABILITIES_LEAF_PATH)).toBe(true);
-  });
-});
-
 describe("renderCapabilityContent", () => {
   const resolvers: CapabilityResolvers = {
     skill: (slug) =>
@@ -100,19 +47,25 @@ describe("renderCapabilityContent", () => {
   });
 });
 
-describe("needle indexes injected capability members", () => {
-  test("a skill slug is lexically retrievable by its title and summary", async () => {
-    const tree = emptyTree();
-    injectCapabilitiesLeaf(tree, new Set<LeafPath>(), ["skills/meet-join"]);
+describe("capabilityOrDiskBody", () => {
+  test("a capability slug routes through renderCapabilityContent and never reads disk", async () => {
+    let diskReads = 0;
+    const readDiskBody = async (): Promise<string> => {
+      diskReads += 1;
+      return "disk body — should not be read";
+    };
+    // A capability slug whose production cache has no entry degrades to "" (the
+    // `renderCapabilityContent` contract) rather than falling through to the
+    // injected disk reader, which must stay untouched.
+    expect(await capabilityOrDiskBody("skills/example", readDiskBody)).toBe("");
+    expect(diskReads).toBe(0);
+  });
 
-    const needle = await buildNeedleIndex(
-      tree,
-      async () => "Join and transcribe a video meeting",
+  test("a non-capability slug returns the injected disk reader's result", async () => {
+    const readDiskBody = async (slug: string): Promise<string> =>
+      `disk body for ${slug}`;
+    expect(await capabilityOrDiskBody("relationship/vows", readDiskBody)).toBe(
+      "disk body for relationship/vows",
     );
-
-    // By slug-derived title token.
-    expect(needle.query("meet", 5)).toContain("skills/meet-join");
-    // By summary token.
-    expect(needle.query("transcribe", 5)).toContain("skills/meet-join");
   });
 });