@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/plugins/__tests__/active-plugin-env.test.ts

@@ -0,0 +1,136 @@
+import { afterEach, describe, expect, spyOn, test } from "bun:test";
+
+import type { SkillSummary } from "../../config/skills.js";
+import * as skills from "../../config/skills.js";
+import type { Conversation } from "../../daemon/conversation.js";
+import * as conversationRegistry from "../../daemon/conversation-registry.js";
+import { PLUGIN_NAME_ENV } from "../../plugin-api/plugin-name-env.js";
+import {
+  applyActivePluginName,
+  uniqueActivePluginOwner,
+} from "../active-plugin-env.js";
+
+function pluginSkill(id: string, pluginId: string): SkillSummary {
+  return {
+    id,
+    name: id,
+    displayName: id,
+    description: id,
+    directoryPath: `/tmp/${id}`,
+    skillFilePath: `/tmp/${id}/SKILL.md`,
+    source: "plugin",
+    owner: { kind: "plugin", id: pluginId },
+  };
+}
+
+function bundledSkill(id: string): SkillSummary {
+  return {
+    id,
+    name: id,
+    displayName: id,
+    description: id,
+    directoryPath: `/tmp/${id}`,
+    skillFilePath: `/tmp/${id}/SKILL.md`,
+    source: "bundled",
+  };
+}
+
+function conversationWithSkills(skillIds: string[]): Conversation {
+  return {
+    skillProjectionState: new Map(skillIds.map((id) => [id, "v1:hash"])),
+  } as Conversation;
+}
+
+describe("uniqueActivePluginOwner", () => {
+  let catalogSpy: ReturnType<typeof spyOn>;
+  let conversationSpy: ReturnType<typeof spyOn>;
+
+  afterEach(() => {
+    catalogSpy?.mockRestore();
+    conversationSpy?.mockRestore();
+  });
+
+  function stub(skillIds: string[], catalog: SkillSummary[]): void {
+    conversationSpy = spyOn(
+      conversationRegistry,
+      "findConversationOrSubagent",
+    ).mockReturnValue(conversationWithSkills(skillIds));
+    catalogSpy = spyOn(skills, "loadSkillCatalog").mockReturnValue(catalog);
+  }
+
+  test("returns the owner when exactly one plugin skill is active", () => {
+    stub(["sms-setup", "bash"], [
+      pluginSkill("sms-setup", "sms"),
+      bundledSkill("bash"),
+    ]);
+    expect(uniqueActivePluginOwner("conv-1")).toBe("sms");
+  });
+
+  test("returns undefined when no plugin skill is active", () => {
+    stub(["bash"], [bundledSkill("bash")]);
+    expect(uniqueActivePluginOwner("conv-1")).toBeUndefined();
+  });
+
+  test("returns undefined when two plugin owners are active", () => {
+    stub(
+      ["sms-setup", "linear-inbox"],
+      [
+        pluginSkill("sms-setup", "sms"),
+        pluginSkill("linear-inbox", "linear"),
+      ],
+    );
+    expect(uniqueActivePluginOwner("conv-1")).toBeUndefined();
+  });
+
+  test("treats two skills from the same plugin as a single owner", () => {
+    stub(
+      ["sms-setup", "sms-send"],
+      [pluginSkill("sms-setup", "sms"), pluginSkill("sms-send", "sms")],
+    );
+    expect(uniqueActivePluginOwner("conv-1")).toBe("sms");
+  });
+
+  test("returns undefined without a conversation id", () => {
+    expect(uniqueActivePluginOwner(undefined)).toBeUndefined();
+    expect(uniqueActivePluginOwner("")).toBeUndefined();
+  });
+});
+
+describe("applyActivePluginName", () => {
+  let catalogSpy: ReturnType<typeof spyOn>;
+  let conversationSpy: ReturnType<typeof spyOn>;
+
+  afterEach(() => {
+    catalogSpy?.mockRestore();
+    conversationSpy?.mockRestore();
+  });
+
+  test("sets VELLUM_PLUGIN_NAME when a unique plugin owner is active", () => {
+    conversationSpy = spyOn(
+      conversationRegistry,
+      "findConversationOrSubagent",
+    ).mockReturnValue(conversationWithSkills(["sms-setup"]));
+    catalogSpy = spyOn(skills, "loadSkillCatalog").mockReturnValue([
+      pluginSkill("sms-setup", "sms"),
+    ]);
+
+    const env: NodeJS.ProcessEnv = {};
+    applyActivePluginName(env, "conv-1");
+    expect(env[PLUGIN_NAME_ENV]).toBe("sms");
+  });
+
+  test("leaves the env unchanged when no unique plugin owner is active", () => {
+    conversationSpy = spyOn(
+      conversationRegistry,
+      "findConversationOrSubagent",
+    ).mockReturnValue(conversationWithSkills(["sms-setup", "linear-inbox"]));
+    catalogSpy = spyOn(skills, "loadSkillCatalog").mockReturnValue([
+      pluginSkill("sms-setup", "sms"),
+      pluginSkill("linear-inbox", "linear"),
+    ]);
+
+    const env: NodeJS.ProcessEnv = {};
+    applyActivePluginName(env, "conv-1");
+    expect(env[PLUGIN_NAME_ENV]).toBeUndefined();
+  });
+});

package/src/plugins/active-plugin-env.ts

@@ -0,0 +1,51 @@
+/**
+ * Inject the owning plugin name into a sanitized child environment when
+ * exactly one plugin-resident skill is active in the conversation.
+ *
+ * Identity comes from the skill catalog `owner` (install-directory
+ * basename), not from the child command or package.json `name`.
+ */
+
+import { loadSkillCatalog } from "../config/skills.js";
+import { findConversationOrSubagent } from "../daemon/conversation-registry.js";
+import { PLUGIN_NAME_ENV } from "../plugin-api/plugin-name-env.js";
+
+/**
+ * Unique catalog owner id among plugin-resident skills active in this
+ * conversation, or undefined when none or more than one plugin is active.
+ */
+export function uniqueActivePluginOwner(
+  conversationId: string | undefined,
+): string | undefined {
+  if (conversationId === undefined || conversationId.length === 0) {
+    return undefined;
+  }
+  const conversation = findConversationOrSubagent(conversationId);
+  if (!conversation) {
+    return undefined;
+  }
+  const owners = new Set<string>();
+  const catalog = loadSkillCatalog();
+  for (const skillId of conversation.skillProjectionState.keys()) {
+    const skill = catalog.find((entry) => entry.id === skillId);
+    if (skill?.owner?.kind === "plugin" && skill.owner.id.length > 0) {
+      owners.add(skill.owner.id);
+    }
+  }
+  if (owners.size !== 1) {
+    return undefined;
+  }
+  return [...owners][0];
+}
+
+/** Set `VELLUM_PLUGIN_NAME` on `env` when a single plugin owner is active. */
+export function applyActivePluginName(
+  env: NodeJS.ProcessEnv,
+  conversationId: string | undefined,
+): void {
+  const owner = uniqueActivePluginOwner(conversationId);
+  if (owner === undefined) {
+    return;
+  }
+  env[PLUGIN_NAME_ENV] = owner;
+}

package/src/plugins/defaults/index.ts

@@ -78,6 +78,9 @@ import surfaceCompletionNudgePostModelCall from "./surface-completion-nudge/hook
 import surfaceCompletionNudgeStop from "./surface-completion-nudge/hooks/stop.js";
 import { resetSurfaceCompletionNudgeStoreForTests } from "./surface-completion-nudge/nudge-state-store.js";
 import surfaceCompletionNudgePkg from "./surface-completion-nudge/package.json" with { type: "json" };
+import taskProgressPostCompact from "./task-progress/hooks/post-compact.js";
+import taskProgressUserPromptSubmit from "./task-progress/hooks/user-prompt-submit.js";
+import taskProgressPkg from "./task-progress/package.json" with { type: "json" };
 import taskProgressNudgePostToolUse, {
   resetTaskProgressNudgeStateForTests,
 } from "./task-progress-nudge/hooks/post-tool-use.js";
@@ -371,6 +374,26 @@ export const defaultExplorationDriftPlugin: Plugin = {
   },
 };
 
+/**
+ * `task-progress`: a `user-prompt-submit` and `post-compact` hook pair that
+ * injects a compact provider-only snapshot of active `task_progress` cards.
+ * Reads canonical conversation surface snapshots from the host helper.
+ * Owns no durable state. Registered after `empty-response` so memory/runtime
+ * injection and refusal quarantine settle first. Built-in history repair
+ * still runs after the user-prompt hook chain. The snapshot is small enough
+ * to re-apply in minimal injection mode.
+ */
+export const defaultTaskProgressPlugin: Plugin = {
+  manifest: {
+    name: taskProgressPkg.name,
+    version: taskProgressPkg.version,
+  },
+  hooks: {
+    "user-prompt-submit": taskProgressUserPromptSubmit,
+    "post-compact": taskProgressPostCompact,
+  },
+};
+
 /**
  * `task-progress-nudge` — a `post-tool-use` hook that nudges the model to show
  * a `task_progress` card once an interactive turn has accumulated several
@@ -440,6 +463,7 @@ export function getAllDefaultPlugins(): readonly Plugin[] {
     defaultImageFallbackPlugin,
     defaultToolResultTruncatePlugin,
     defaultEmptyResponsePlugin,
+    defaultTaskProgressPlugin,
     defaultMaxTokensContinuePlugin,
     defaultToolErrorPlugin,
     defaultExplorationDriftPlugin,

package/src/plugins/defaults/memory/AGENTS.md

@@ -68,6 +68,13 @@ Everything else under the plugin root is **spine**:
   the writer plus the one matcher every reader uses. It lives at the root
   precisely so `substrate/`, `graph/`, and `graph-topology/` can all reach it
   without a tier importing spine. Do not add a second matcher anywhere),
+  `buffer-file` (the two writers of `memory/buffer.md`: the append every
+  `remember()`-shaped path uses and the consume the consolidation job runs
+  after a pass. Do not write the buffer from anywhere else, and never
+  rewrite it from a read that is not inside `consumeBufferEntries`'s
+  synchronous critical section), `memory-run-evidence` (readers of what a
+  background memory run durably produced from its persisted messages; every
+  job that gates a state transition on a verified write uses them),
   `segmenter`, `message-media`, `worker`, `worker-control`,
   `memory-recall-log-store`, `activation-session-store` (the onboarding
   activation rail — **not** a memory tier despite the name),
@@ -213,7 +220,8 @@ not break.
   behind a re-injected copy), and a reset whose ledger clear fails reports
   that the same way a missing marker does.
 - **The store is plugin-owned.** `memory_v3_injected_sections`,
-  `memory_v3_pools`, and the `section_key` column of `memory_v3_selections`
+  `memory_v3_pools`, `memory_v3_pool_inputs`, `memory_v3_pool_texts`, and
+  the `section_key` column of `memory_v3_selections`
   are created by `v3/plugin-schema.ts` (`ensureMemoryV3PluginSchema` from the
   `init` hook, and each store's once-per-connection ensure on first use),
   never by the global migration chain, and every read goes through its
@@ -365,13 +373,16 @@ Persisted rows; a rename orphans every existing install.
 | `memory_v2_injection_events`      | v2 scoring feedback                                             |
 | `memory_v3_selections`            | v3 selection log (`section_key` column plugin-added, see below) |
 | `memory_v3_pools`                 | v3 selector pool audit (plugin-created, see below)              |
+| `memory_v3_pool_inputs`           | v3 selector input capture, opt-in (plugin-created, see below)   |
+| `memory_v3_pool_texts`            | v3 pooled candidate texts by content hash, opt-in (see below)   |
 | `memory_v3_injected_sections`     | v3 section dedup, prune bytes + recency (plugin-created, below) |
 | `memory_v3_ever_injected`         | v3 card dedup (superseded, frozen)                              |
 | `memory_retrospective_state`      | retrospective (tier-agnostic)                                   |
 | `activation_sessions`             | onboarding activation rail                                      |
 
-`memory_v3_pools` and `memory_v3_injected_sections` are the plugin's own
-tables, created by the plugin rather than by the global migration chain
+`memory_v3_pools`, `memory_v3_pool_inputs`, `memory_v3_pool_texts`, and
+`memory_v3_injected_sections` are the plugin's own tables, created by the
+plugin rather than by the global migration chain
 (`v3/plugin-schema.ts`): the memory plugin's `init` hook ensures both on every
 boot, and each store ensures again on the first use of a connection in its
 process (the memory worker is a separate process), idempotently and fail-open,
@@ -407,8 +418,13 @@ per distinct matched section, at most `memory.v3.finderSectionsPerPage` in
 surfacing order (needle, dense, reply, span) plus its entity and rare-term
 lines, and selecting a line selects that section; the selection log keeps
 one row per slug, so the pool row is where the per-section verdicts live. A
-turn whose selector never judged a pool (the injection gate hard-skipped it,
-or nothing was pooled) persists an empty pool with `selector_ran = 0`, and a
+turn whose selector never judged a pool persists it with `selector_ran = 0`:
+an empty pool when the injection gate hard-skipped it or nothing was pooled,
+and the pool as the selector was given it, stable-prefix cards chosen and
+finder lines not, when the selector's provider failed and the orchestrator
+kept that prefix unjudged. That turn writes no `memory_v3_selections` rows:
+the hot set's frecency and the learned-edge graph read that table as
+judgments, and an unjudged page is not one. A
 turn that logged no selections is still reachable by its stamped
 `message_id`, so the inspector shows negative verdicts too. The pool row and
 the turn's `memory_v3_selections` rows are
@@ -419,6 +435,24 @@ diagnostics, roughly 10KB each, with no retention job; a conversation delete
 purges them with the other conversation-keyed tables
 (`conversation-memory-purge.ts`).
 
+`memory_v3_pool_inputs` and `memory_v3_pool_texts` (`v3/pool-log-store.ts`,
+written only under `memory.v3.poolLog.captureInput`, off by default) extend
+the pool row with the selector's exact input, for offline selector
+evaluation and training data. One `memory_v3_pool_inputs` row per turn
+holds the context strings the selector was given (situation, recent context,
+current message, the previous assistant reply), the selector prompt's
+content hash, the gate reason, the keep-all flag, and the content hash of
+every pooled candidate's rendered text in pool order, aligned index for
+index with the pool row's `candidates_json` (pool position `i + 1` is the
+number the selector saw candidate `i` under). `memory_v3_pool_texts` holds
+each rendered text once by that hash: a stable-prefix card is its
+pre-rendered card, a finder line is exactly the line the selector saw minus
+its number (`renderFinderLine` in `v3/pool-select.ts`), and a card repeated
+across turns is stored once. The input row is written in the transaction
+that writes the pool and selection rows and purged with the conversation;
+the texts table is page-derived and keyed by content, so it is never purged
+per conversation.
+
 **v3 finder lanes.** The per-turn finder lanes (`v3/orchestrate.ts`) surface
 candidates in a fixed order, needle, dense, reply, span, entity, rare, then
 edge and learned, and each only ever adds lines. The entity lane

package/src/plugins/defaults/memory/__tests__/archive-removal-framing.test.ts

@@ -0,0 +1,64 @@
+/**
+ * The daily archive (`memory/archive/`) holds raw buffer entries only. Per-turn
+ * injection reads concept pages and never the archive, and text a pass
+ * composes or derives on a page is not in it. So nothing the consolidation
+ * agent reads may present the archive as making removal safe: that framing
+ * licenses deleting filed content that exists nowhere else.
+ *
+ * The check is sentence-level: no sentence may pair the archive with
+ * reassurance that removing content loses nothing. A sentence warning that
+ * removed text IS lost stays allowed.
+ */
+import { describe, expect, test } from "bun:test";
+
+import { renderConsolidationPrompt } from "../substrate/prompts/consolidation.js";
+import { deleteMemoryPageTool } from "../tools.js";
+
+function archiveSafetyClaims(text: string): string[] {
+  return text
+    .split(/(?<=[.!?])\s+/)
+    .filter(
+      (sentence) =>
+        /archive/i.test(sentence) &&
+        /don.t worry|no need to worry|never los|nothing is lost|won.t lose|safe to (?:delete|remove|cut|drop)/i.test(
+          sentence,
+        ),
+    );
+}
+
+describe("the archive is never framed as making removal safe", () => {
+  test("neither consolidation article shape makes the claim", () => {
+    const v2 = renderConsolidationPrompt("May 1, 12:00 PM", {
+      includeCorePagesSection: false,
+      articleShape: "v2",
+      bufferEntries: "",
+    });
+    // The over-long-sections step carries the one legitimate archive
+    // sentence, so the v3 render includes it.
+    const v3 = renderConsolidationPrompt("May 1, 12:00 PM", {
+      includeCorePagesSection: true,
+      articleShape: "v3",
+      bufferEntries: "",
+      overlongSections: {
+        windowChars: 6000,
+        sections: [{ slug: "journal", title: "", chars: 7200 }],
+      },
+    });
+
+    expect(v3).toContain("the archive is a record");
+    expect(archiveSafetyClaims(v2)).toEqual([]);
+    expect(archiveSafetyClaims(v3)).toEqual([]);
+  });
+
+  test("a warning that removed text is lost is not the claim", () => {
+    expect(
+      archiveSafetyClaims(
+        "Text you cut from a page is lost to retrieval: the archive does not bring it back.",
+      ),
+    ).toEqual([]);
+  });
+
+  test("the delete_memory_page description does not make the claim", () => {
+    expect(archiveSafetyClaims(deleteMemoryPageTool.description)).toEqual([]);
+  });
+});