@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/plugin-api/resolve-credential.ts

@@ -1,28 +1,42 @@
 /**
  * Plugin-facing credential resolution.
  *
- * {@link resolveCredential} returns a stored credential's plaintext value — the
- * same value `assistant credentials reveal` prints — resolving a reference that
- * is either a credential UUID or a `"service/field"` string, exactly as the
- * reveal path does (see {@link ../tools/credentials/resolve.resolveCredentialRef}
- * and the `credentials/reveal` route).
+ * {@link resolveCredential} returns a stored credential's plaintext value
+ * (the same value `assistant credentials reveal` prints), resolving a
+ * reference that is either a credential UUID or a `"service/field"` string,
+ * exactly as the reveal path does (see
+ * {@link ../tools/credentials/resolve.resolveCredentialRef} and the
+ * `credentials/reveal` route).
  *
  * ## Plugin scoping
  *
- * When a plugin is in context (its hook, tool, or one of its own
- * `/x/plugins/<name>/` routes is executing, tracked by
- * {@link ../plugins/plugin-execution-context.getCurrentPluginName}), resolution
- * is restricted: the plugin may only resolve credentials whose `service`
- * equals its manifest name (`imessage/api_key` for plugin `imessage`). It
- * cannot read another service (`openai/api_key`, `openai/imessage`). Outside
- * any plugin context (host-internal callers, CLI, tests) the resolver is
- * unscoped and behaves like a direct reveal.
+ * When a plugin is in context, resolution is restricted to credentials
+ * whose `service` equals the plugin's runtime install-directory name
+ * (`sms/account_sid` for plugin `sms`). Context is:
+ *
+ * 1. In-process AsyncLocalStorage from `runInPluginContext` (hooks, plugin
+ *    tools, plugin routes).
+ * 2. `VELLUM_PLUGIN_NAME` on a bash or skill-sandbox child.
+ * 3. The process entry path, when it sits under
+ *    `plugins/<service>/skills/<skill>/{scripts,tools}/`.
+ *
+ * Outside any plugin context the resolver is unscoped and behaves like a
+ * direct reveal. A standalone child has an empty in-process metadata
+ * cache; when plugin context is set, a cache miss consults the live
+ * credential catalog so an empty cache is not reported as "not found".
  */
 
-import { getCurrentPluginName } from "../plugins/plugin-execution-context.js";
+import { credentialKey } from "@vellumai/credential-storage";
+
 import { getSecureKeyResultAsync } from "../security/secure-keys.js";
+import {
+  type CredentialMetadata,
+  listCredentialRecordsLive,
+} from "../tools/credentials/metadata-store.js";
+import { parseServiceFieldRef } from "../tools/credentials/ref-parse.js";
 import { resolveCredentialRef } from "../tools/credentials/resolve.js";
 import { credentialInPluginScope } from "./credential-scope.js";
+import { resolveCallingPluginName } from "./plugin-name-env.js";
 
 /**
  * Raised when a credential cannot be resolved: the reference does not match a
@@ -36,6 +50,50 @@ export class CredentialResolutionError extends Error {
   }
 }
 
+interface ResolvedRef {
+  service: string;
+  field: string;
+  storageKey: string;
+}
+
+function findLiveRecord(
+  records: CredentialMetadata[],
+  ref: string,
+): CredentialMetadata | undefined {
+  const byId = records.find((record) => record.credentialId === ref);
+  if (byId) {
+    return byId;
+  }
+  const parsed = parseServiceFieldRef(ref);
+  if (!parsed) {
+    return undefined;
+  }
+  return records.find(
+    (record) =>
+      record.service === parsed.service && record.field === parsed.field,
+  );
+}
+
+async function resolveCredentialRefLive(
+  ref: string,
+): Promise<ResolvedRef | undefined> {
+  const live = await listCredentialRecordsLive();
+  if (live.unreachable) {
+    throw new CredentialResolutionError(
+      "Credential store is unreachable.",
+    );
+  }
+  const record = findLiveRecord(live.records, ref);
+  if (!record) {
+    return undefined;
+  }
+  return {
+    service: record.service,
+    field: record.field,
+    storageKey: credentialKey(record.service, record.field),
+  };
+}
+
 /**
  * Resolve a credential reference to its plaintext value.
  *
@@ -45,15 +103,16 @@ export class CredentialResolutionError extends Error {
  *   store is unreachable, or a plugin in context is not scoped to the credential.
  */
 export async function resolveCredential(ref: string): Promise<string> {
-  const resolved = resolveCredentialRef(ref);
+  const pluginName = resolveCallingPluginName();
+
+  let resolved: ResolvedRef | undefined = resolveCredentialRef(ref);
+  if (!resolved && pluginName !== undefined) {
+    resolved = await resolveCredentialRefLive(ref);
+  }
   if (!resolved) {
     throw new CredentialResolutionError(`Credential not found: ${ref}`);
   }
 
-  // Scope the resolution to the plugin in context, if any. The ownership gate
-  // is enforced before the plaintext is read so an out-of-scope plugin never
-  // touches the secure backend.
-  const pluginName = getCurrentPluginName();
   if (
     pluginName !== undefined &&
     !credentialInPluginScope(pluginName, resolved.service)
@@ -70,7 +129,7 @@ export async function resolveCredential(ref: string): Promise<string> {
   if (value == null || value.length === 0) {
     if (unreachable) {
       throw new CredentialResolutionError(
-        "Credential store is unreachable — ensure the assistant is running",
+        "Credential store is unreachable.",
       );
     }
     throw new CredentialResolutionError(`Credential not found: ${ref}`);

package/src/plugin-api/vision-support.test.ts

@@ -397,3 +397,25 @@ describe("doesSupportVision with a bare string", () => {
     expect(doesSupportVision("qwen2.5-vl")).toBe(true);
   });
 });
+
+describe("doesSupportVision with a resolved target", () => {
+  test("profile policy can enable images for a catalog text model", () => {
+    expect(
+      doesSupportVision({
+        provider: "fireworks",
+        model: "accounts/fireworks/models/glm-5p2",
+        inputModalities: { image: { enabled: true, supported: true } },
+      }),
+    ).toBe(true);
+  });
+
+  test("profile policy can disable images for a catalog vision model", () => {
+    expect(
+      doesSupportVision({
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+        inputModalities: { image: { enabled: false } },
+      }),
+    ).toBe(false);
+  });
+});

package/src/plugin-api/vision-support.ts

@@ -37,15 +37,24 @@ import {
 } from "../providers/model-catalog.js";
 import type { ModelProfileInfo } from "./types.js";
 
+/** A fully resolved provider target plus the winning profile's policy. */
+export interface ResolvedVisionTarget {
+  readonly provider?: string;
+  readonly model: string;
+  readonly inputModalities?: InputModalities | null;
+}
+
 /**
  * Whether the given model or profile can process image input.
  *
- * `modelOrProfile` may be a concrete model id, a profile key, or a
- * {@link ModelProfileInfo}. A bare string is resolved as a model id first and,
- * failing that, as a profile key. Returns `false` when nothing resolves.
+ * `modelOrProfile` may be a concrete model id, a profile key, a
+ * {@link ModelProfileInfo}, or a fully resolved target. A resolved target
+ * combines the final provider/model with the winning profile's modality
+ * policy. A bare string is resolved as a model id first and, failing that, as
+ * a profile key. Returns `false` when nothing resolves.
  */
 export function doesSupportVision(
-  modelOrProfile: ModelProfileInfo | string,
+  modelOrProfile: ModelProfileInfo | ResolvedVisionTarget | string,
 ): boolean {
   if (typeof modelOrProfile === "string") {
     // Concrete catalog model id first, then a profile key, then any profile
@@ -58,7 +67,10 @@ export function doesSupportVision(
       false
     );
   }
-  return profileVision(modelOrProfile.key) ?? false;
+  if ("key" in modelOrProfile) {
+    return profileVision(modelOrProfile.key) ?? false;
+  }
+  return resolveEntryVision(modelOrProfile) ?? false;
 }
 
 /**

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/__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([]);
+  });
+});

package/src/plugins/defaults/memory/__tests__/worker-control.test.ts

@@ -231,18 +231,26 @@ describe("spawnMemoryWorkerProcess", () => {
     }
   });
 
-  test("reuses an already-running worker without spawning", async () => {
-    // A live PID file (this test process) makes the probe report running.
+  test("spawns when the PID file names an unrelated live process", async () => {
     writeFileSync(pidPath, String(process.pid));
     let spawned = false;
     const restore = stubBunSpawn(() => {
       spawned = true;
-      return { unref: () => {}, kill: () => {}, pid: 1, exited: neverExits() };
+      writeFileSync(pidPath, "4242");
+      return {
+        unref: () => {},
+        kill: () => {},
+        pid: 4242,
+        exited: neverExits(),
+      };
     });
     try {
-      const result = await spawnMemoryWorkerProcess({ pidWaitTimeoutMs: 100 });
-      expect(result).toEqual({ pid: process.pid, alreadyRunning: true });
-      expect(spawned).toBe(false);
+      const result = await spawnMemoryWorkerProcess({
+        pidWaitTimeoutMs: 1_000,
+        pidPollIntervalMs: 10,
+      });
+      expect(result).toEqual({ pid: 4242, alreadyRunning: false });
+      expect(spawned).toBe(true);
     } finally {
       restore();
     }
@@ -250,6 +258,11 @@ describe("spawnMemoryWorkerProcess", () => {
 });
 
 describe("probeMemoryWorker", () => {
+  test("reports not_running when the PID file names a live process that is not this worker", () => {
+    writeFileSync(pidPath, String(process.pid));
+    expect(probeMemoryWorker()).toEqual({ status: "not_running" });
+  });
+
   test("reports running (not throws) when the process exists but is not signalable (EPERM)", () => {
     writeFileSync(pidPath, "4321");
     const restore = stubProcessKill(new Set(), new Set([4321]));

package/src/plugins/defaults/memory/context-search/agent-protocol.ts

@@ -1,6 +1,10 @@
+import {
+  type RecallSource,
+  RecallSourceSchema,
+} from "../../../../api/events/tool-result.js";
 import { truncate } from "../host-utils.js";
-import { ALL_RECALL_SOURCES, normalizeRecallSources } from "./limits.js";
-import type { RecallEvidence, RecallSource } from "./types.js";
+import { normalizeRecallSources } from "./limits.js";
+import type { RecallEvidence } from "./types.js";
 
 export type RecallAgentConfidence = "high" | "medium" | "low";
 
@@ -76,7 +80,7 @@ export const SEARCH_SOURCES_TOOL_DEFINITION: RecallAgentToolDefinition = {
       sources: {
         type: "array",
         description: "Optional subset of internal sources to search.",
-        items: { type: "string", enum: [...ALL_RECALL_SOURCES] },
+        items: { type: "string", enum: [...RecallSourceSchema.options] },
         uniqueItems: true,
       },
       limit: {
@@ -176,9 +180,9 @@ export function buildRecallAgentPromptBundle(
 ): RecallAgentPromptBundle {
   const availableSources = normalizeRecallSources(options.availableSources);
   const maxSearchCalls = options.maxSearchCalls ?? DEFAULT_MAX_SEARCH_CALLS;
-  const evidence = prepareRecallAgentPromptEvidence(
+  const evidence = truncateRecallEvidenceToBudget(
     options.evidence,
-    options.evidenceBudgetChars,
+    options.evidenceBudgetChars ?? DEFAULT_RECALL_AGENT_EVIDENCE_BUDGET_CHARS,
   );
   const citationIds = evidence.map((item) => item.id);
 
@@ -216,13 +220,6 @@ export function buildRecallAgentPromptBundle(
   return { prompt, evidence };
 }
 
-function prepareRecallAgentPromptEvidence(
-  evidence: readonly RecallEvidence[],
-  evidenceBudgetChars = DEFAULT_RECALL_AGENT_EVIDENCE_BUDGET_CHARS,
-): RecallEvidence[] {
-  return truncateRecallEvidenceToBudget(evidence, evidenceBudgetChars);
-}
-
 export function truncateRecallEvidenceToBudget(
   evidence: readonly RecallEvidence[],
   maxTextChars: number,