@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/runtime/routes/migration-routes.ts

@@ -24,7 +24,12 @@ import { getPlatformAssistantId } from "../../config/env.js";
 import { invalidateConfigCache } from "../../config/loader.js";
 import { getAssistantName } from "../../daemon/identity-helpers.js";
 import { runAsyncSqlite } from "../../memory/db-async-query.js";
-import { getDb, resetDb } from "../../memory/db-connection.js";
+import {
+  getDb,
+  getLogsSqlite,
+  getMemorySqlite,
+  resetDb,
+} from "../../memory/db-connection.js";
 import { validateMigrationState } from "../../memory/migrations/validate-migration-state.js";
 import { credentialKey } from "../../security/credential-key.js";
 import {
@@ -151,6 +156,49 @@ export async function reconcileVellumMetadataFromCes(warningSink: {
 
 const log = getLogger("migration-routes");
 
+/**
+ * Flush each database file's WAL before an export copies them. The bundle
+ * walker includes `*.db` but skips `*.db-wal`, so committed frames still sitting
+ * in a WAL would be missing from the bundle.
+ *
+ * The main DB is flushed through `runAsyncSqlite` so the (potentially multi-GB)
+ * flush runs in a sqlite3 subprocess where available rather than stalling the
+ * event loop. The dedicated logs/memory connections are checkpointed in-process
+ * on their own handles — they are small and the daemon already holds them open.
+ * FULL (not TRUNCATE) writes committed frames back to the main file, which is
+ * all the copy needs.
+ */
+async function checkpointDbsForExport(): Promise<void> {
+  const mainResult = await runAsyncSqlite("PRAGMA wal_checkpoint(FULL)");
+  if (!mainResult.ok) {
+    log.warn(
+      { error: mainResult.error, backend: mainResult.backend, db: "main" },
+      "WAL checkpoint failed — exporting without checkpoint",
+    );
+  }
+
+  for (const [label, sqlite] of [
+    ["logs", getLogsSqlite()],
+    ["memory", getMemorySqlite()],
+  ] as const) {
+    if (!sqlite) {
+      log.warn(
+        { db: label },
+        "Dedicated database unavailable — exporting without checkpoint",
+      );
+      continue;
+    }
+    try {
+      sqlite.exec("PRAGMA wal_checkpoint(FULL)");
+    } catch (err) {
+      log.warn(
+        { err, db: label },
+        "WAL checkpoint failed — exporting without checkpoint",
+      );
+    }
+  }
+}
+
 /**
  * Fields the export pipeline must populate on the v1 manifest.
  *
@@ -353,28 +401,7 @@ export async function handleMigrationExport(
       ...manifestInputs,
       secretsRedacted,
       credentials,
-      checkpoint: async () => {
-        // Dispatch through `runAsyncSqlite` so the WAL checkpoint runs
-        // in a sqlite3 subprocess on hosts where it's available. A WAL
-        // flush on a multi-GB WAL file can otherwise stall the daemon's
-        // event loop for the full duration of the flush.
-        //
-        // FULL (not TRUNCATE): FULL blocks until every committed frame is
-        // written back to the main `.db` file, which is all the export
-        // needs since it copies that file. TRUNCATE additionally restarts
-        // the WAL and truncates it to zero bytes — extra work and blocking
-        // this path does not need.
-        const result = await runAsyncSqlite("PRAGMA wal_checkpoint(FULL)");
-        if (!result.ok) {
-          // Best-effort: if the DB can't be checkpointed (e.g. not a valid
-          // SQLite file, missing WAL, etc.) we still proceed with the export
-          // using whatever is on disk.
-          log.warn(
-            { error: result.error, backend: result.backend },
-            "WAL checkpoint failed — exporting without checkpoint",
-          );
-        }
-      },
+      checkpoint: checkpointDbsForExport,
     });
 
     cleanup = result.cleanup;
@@ -582,23 +609,7 @@ export async function handleMigrationExportToGcs({ body }: RouteHandlerArgs) {
           ...manifestInputs,
           secretsRedacted,
           credentials: collected.credentials,
-          checkpoint: async () => {
-            // Dispatch through `runAsyncSqlite` so the WAL checkpoint runs
-            // in a sqlite3 subprocess on hosts where it's available. A
-            // WAL flush on a multi-GB WAL file can otherwise stall the
-            // daemon's event loop for the full duration of the flush.
-            //
-            // FULL (not TRUNCATE): see the disk-export checkpoint above
-            // for rationale. assistant/AGENTS.md "SQLite WAL
-            // checkpointing".
-            const result = await runAsyncSqlite("PRAGMA wal_checkpoint(FULL)");
-            if (!result.ok) {
-              log.warn(
-                { error: result.error, backend: result.backend },
-                "WAL checkpoint failed — exporting without checkpoint",
-              );
-            }
-          },
+          checkpoint: checkpointDbsForExport,
         });
 
         cleanup = result.cleanup;

package/src/runtime/routes/plugins-routes.ts

@@ -50,6 +50,12 @@ import {
   getPluginDetails,
   PluginDetailsNotFoundError,
 } from "../../cli/lib/plugin-details.js";
+import {
+  DEFAULT_PIN_HISTORY_LIMIT,
+  listPinHistory,
+  PluginPinHistoryError,
+  resolvePinToMarketplaceCommit,
+} from "../../cli/lib/plugin-pin-history.js";
 import {
   assertValidSearchPattern,
   filterPluginCatalog,
@@ -73,6 +79,7 @@ import {
   ConflictError,
   InternalError,
   NotFoundError,
+  RouteError,
   ServiceUnavailableError,
 } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -236,6 +243,12 @@ const pluginInstallRequestSchema = z.object({
     .boolean()
     .optional()
     .describe("Overwrite an existing install in place. Defaults to false."),
+  pin: z
+    .string()
+    .optional()
+    .describe(
+      "Install a specific reviewed marketplace pin (full commit SHA) instead of the current one. The pin is validated against the plugin's marketplace pin history (`GET /v1/plugins/:name/versions`) and installed from the marketplace revision that introduced it; an unreviewed SHA is rejected. Use this to roll a plugin back to an older reviewed version.",
+    ),
 });
 
 const pluginInstallResponseSchema = z.object({
@@ -250,6 +263,32 @@ const pluginInstallResponseSchema = z.object({
   ref: z.string().describe("Git ref the plugin was fetched from."),
 });
 
+const pluginPinHistoryEntrySchema = z.object({
+  pin: z
+    .string()
+    .describe("Plugin commit SHA pinned at this point in marketplace history."),
+  marketplaceCommit: z
+    .string()
+    .describe(
+      "Marketplace-manifest commit to install this pin from (the newest commit carrying it).",
+    ),
+  promotedAt: z
+    .string()
+    .nullable()
+    .describe(
+      "ISO-8601 committer date (UTC) of the marketplace commit that promoted this pin; null when unreadable.",
+    ),
+  current: z
+    .boolean()
+    .describe("True for the pin currently active on the default branch."),
+});
+
+const pluginVersionsResponseSchema = z
+  .array(pluginPinHistoryEntrySchema)
+  .describe(
+    "Distinct marketplace pins a plugin has been promoted to, newest first; the first entry is the current pin. Empty when the plugin has no resolvable history.",
+  );
+
 const fingerprintComparisonSchema = z
   .object({
     modified: z
@@ -771,23 +810,52 @@ async function handleGetPluginDetails({
 // Handler — install
 // ---------------------------------------------------------------------------
 
+/**
+ * Resolve the marketplace ref an install should read from. With no `pin`, that
+ * is the default reviewed branch. With a `pin`, it is the marketplace commit
+ * that introduced that pin — but only when the pin appears in the plugin's
+ * reviewed history; an unreviewed SHA is rejected as a bad request so the route
+ * never installs an unvetted revision.
+ */
+async function resolveInstallMarketplaceRef(
+  name: string,
+  pin: string | undefined,
+): Promise<string> {
+  if (!pin) return DEFAULT_PLUGIN_REF;
+  const entry = await resolvePinToMarketplaceCommit(name, pin, {
+    fetch: globalThis.fetch.bind(globalThis),
+  });
+  if (!entry) {
+    throw new BadRequestError(
+      `"${pin}" is not a reviewed marketplace pin for "${name}". ` +
+        `Use GET /v1/plugins/${name}/versions to list installable pins.`,
+    );
+  }
+  return entry.marketplaceCommit;
+}
+
 async function handleInstallPlugin({ body = {} }: RouteHandlerArgs) {
   const name = typeof body.name === "string" ? body.name : "";
   if (!name) {
     throw new BadRequestError("`name` is required");
   }
   const force = typeof body.force === "boolean" ? body.force : undefined;
+  const pin = typeof body.pin === "string" ? body.pin : undefined;
 
-  // The ref is pinned to the curated `DEFAULT_PLUGIN_REF` rather than taken
-  // from the request: a caller-supplied ref would let any `settings.write`
-  // principal install from an unreviewed revision (a PR branch, fork ref,
-  // ...) whose marketplace manifest could carry attacker code that the loader
-  // then dynamically imports. Installs over HTTP therefore only ever resolve
-  // against the reviewed catalog on the default ref. Operators who need
-  // another ref use the local CLI's `assistant plugins install --ref`.
+  // The marketplace ref is never taken raw from the request: a caller-supplied
+  // ref would let any `settings.write` principal install from an unreviewed
+  // revision (a PR branch, fork ref, ...) whose manifest could carry attacker
+  // code the loader then dynamically imports. Installs over HTTP therefore
+  // resolve only against reviewed history. A `pin` is honored by mapping it —
+  // server-side — to the marketplace commit that introduced it, but only if it
+  // appears in the plugin's reviewed pin history; an unreviewed SHA is refused.
+  // The default install reads the current catalog on `DEFAULT_PLUGIN_REF`.
+  // Operators who need an unreviewed revision use the local CLI's
+  // `assistant plugins install --pin <sha> --allow-unreviewed`.
   try {
+    const marketplaceRef = await resolveInstallMarketplaceRef(name, pin);
     const result = await installPlugin(
-      { name, ref: DEFAULT_PLUGIN_REF, force },
+      { name, ref: marketplaceRef, force },
       { fetch: globalThis.fetch.bind(globalThis) },
     );
     return {
@@ -798,6 +866,11 @@ async function handleInstallPlugin({ body = {} }: RouteHandlerArgs) {
       ref: result.ref,
     };
   } catch (err) {
+    // Pin resolution already maps unreviewed/bad-pin cases to a RouteError;
+    // re-throw those verbatim rather than masking them as a 500.
+    if (err instanceof RouteError) {
+      throw err;
+    }
     if (err instanceof InvalidPluginNameError) {
       throw new BadRequestError(err.message);
     }
@@ -812,6 +885,10 @@ async function handleInstallPlugin({ body = {} }: RouteHandlerArgs) {
     if (err instanceof PluginSourceUnavailableError) {
       throw new ServiceUnavailableError(err.message);
     }
+    // The pin-history read hits GitHub too; treat its failures as retryable.
+    if (err instanceof PluginPinHistoryError) {
+      throw new ServiceUnavailableError(err.message);
+    }
     throw new InternalError(
       err instanceof Error ? err.message : "plugin install failed",
     );
@@ -846,6 +923,45 @@ async function handleInspectPlugin({ pathParams = {} }: RouteHandlerArgs) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Handler — versions (marketplace pin history)
+// ---------------------------------------------------------------------------
+
+async function handlePluginVersions({
+  pathParams = {},
+  queryParams = {},
+}: RouteHandlerArgs) {
+  const rawName = pathParams.name ?? "";
+
+  let limit: number | undefined;
+  if (queryParams.limit !== undefined) {
+    const parsed = Number.parseInt(queryParams.limit, 10);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+      throw new BadRequestError("`limit` must be a positive integer.");
+    }
+    limit = parsed;
+  }
+
+  try {
+    return await listPinHistory(
+      rawName,
+      { fetch: globalThis.fetch.bind(globalThis) },
+      limit !== undefined ? { limit } : {},
+    );
+  } catch (err) {
+    if (err instanceof InvalidPluginNameError) {
+      throw new BadRequestError(err.message);
+    }
+    // The history read hits GitHub; its failures are retryable upstream errors.
+    if (err instanceof PluginPinHistoryError) {
+      throw new ServiceUnavailableError(err.message);
+    }
+    throw new InternalError(
+      err instanceof Error ? err.message : "plugin versions failed",
+    );
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Handler — diff
 // ---------------------------------------------------------------------------
@@ -1150,6 +1266,46 @@ export const ROUTES: RouteDefinition[] = [
     },
     handler: handleInspectPlugin,
   },
+  {
+    operationId: "plugins_versions",
+    endpoint: "plugins/:name/versions",
+    method: "GET",
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "List a plugin's reviewed marketplace pins",
+    description: `Report the distinct marketplace pins a plugin has been promoted to over time, newest first (the first entry is the current pin), capped at \`limit\` (default ${DEFAULT_PIN_HISTORY_LIMIT}). The curated \`marketplace.json\` stores only the current pin, so this is reconstructed from the manifest's own commit history on the default branch — every entry is therefore a reviewed, known-good revision. Pair with \`POST /v1/plugins/install\`'s \`pin\` field to roll a plugin back to an older reviewed version. An unknown name (never in the manifest) returns an empty array, not 404.`,
+    tags: ["plugins"],
+    pathParams: [
+      {
+        name: "name",
+        type: "string",
+        description:
+          "Install name. Must match the kebab-case name accepted by `assistant plugins install`.",
+      },
+    ],
+    queryParams: [
+      {
+        name: "limit",
+        type: "string",
+        required: false,
+        description: `Maximum number of pins to return (positive integer; default ${DEFAULT_PIN_HISTORY_LIMIT}).`,
+      },
+    ],
+    responseBody: pluginVersionsResponseSchema,
+    additionalResponses: {
+      "400": {
+        description:
+          "The plugin name failed sanitization, or `limit` was not a positive integer.",
+      },
+      "503": {
+        description:
+          "The marketplace pin history could not be read from GitHub (rate-limited or upstream error); retryable.",
+      },
+    },
+    handler: handlePluginVersions,
+  },
   {
     operationId: "plugins_diff",
     endpoint: "plugins/:name/diff",

package/src/runtime/routes/schedule-routes.ts

@@ -1061,6 +1061,7 @@ async function handleRunScheduleNow(id: string) {
         conversationId: schedule.wakeConversationId,
         hint: schedule.message,
         source: "defer",
+        persistTriggerAsEvent: true,
         ...(schedule.inferenceProfile
           ? { forceOverrideProfile: schedule.inferenceProfile }
           : {}),

package/src/runtime/routes/usage-routes.ts

@@ -65,6 +65,9 @@ const usageGroupBreakdownSchema = z.object({
   totalCacheReadTokens: z.number(),
   totalEstimatedCostUsd: z.number(),
   eventCount: z.number(),
+  // Distinct conversation turns; populated only for the conversation grouping,
+  // null otherwise (and for the conversation "Other" bucket).
+  turnCount: z.number().nullable(),
 });
 
 const usageSeriesGroupValueSchema = z.object({

package/src/runtime/routes/work-items-routes.test.ts

@@ -25,7 +25,7 @@ import { createWorkItem } from "../../work-items/work-item-store.js";
 import { ForbiddenError } from "./errors.js";
 import { preflightWorkItem, ROUTES } from "./work-items-routes.js";
 
-initializeDb();
+await initializeDb();
 
 describe("empty required_tools snapshot bypass", () => {
   test("falls back to task required tools when snapshot requiredTools is empty", async () => {

package/src/runtime/slack-block-formatting.ts

@@ -1,36 +1,16 @@
 /**
- * Lightweight Block Kit block generation for Slack channel replies.
+ * Block Kit block generation for Slack channel replies.
  *
- * The gateway's text-to-blocks utility handles the full conversion, but
- * the assistant pre-generates blocks so the gateway can pass them through
- * without re-parsing. This keeps the conversion logic self-contained and
- * avoids the gateway needing to distinguish pre-formatted from raw text.
+ * Converts markdown/plain text into Slack Block Kit blocks (typed via
+ * `@slack/types`) so the assistant can attach pre-formatted `blocks` to a
+ * Slack delivery. Handles code fences, headers, markdown tables, and
+ * oversize-section splitting.
  */
 
-// ---------------------------------------------------------------------------
-// Block types (mirrors gateway/src/slack/block-kit-builder.ts)
-// ---------------------------------------------------------------------------
-
-interface TextObject {
-  type: "mrkdwn" | "plain_text";
-  text: string;
-}
-
-interface SectionBlock {
-  type: "section";
-  text: TextObject;
-}
-
-interface DividerBlock {
-  type: "divider";
-}
-
-interface HeaderBlock {
-  type: "header";
-  text: TextObject;
-}
+import type { KnownBlock } from "@slack/types";
 
-type Block = SectionBlock | DividerBlock | HeaderBlock;
+/** Slack rejects messages with more than 50 Block Kit blocks. */
+const SLACK_BLOCK_LIMIT = 50;
 
 // ---------------------------------------------------------------------------
 // Public API
@@ -42,11 +22,11 @@ type Block = SectionBlock | DividerBlock | HeaderBlock;
  * Returns undefined when the input is empty so callers can
  * skip sending the `blocks` field entirely.
  */
-export function textToSlackBlocks(text: string): Block[] | undefined {
+export function textToSlackBlocks(text: string): KnownBlock[] | undefined {
   if (!text || text.trim().length === 0) return undefined;
 
   const segments = splitIntoSegments(text);
-  const blocks: Block[] = [];
+  const blocks: KnownBlock[] = [];
 
   for (let i = 0; i < segments.length; i++) {
     if (i > 0) {
@@ -116,6 +96,25 @@ export function textToSlackBlocks(text: string): Block[] | undefined {
     }
   }
 
+  if (blocks.length > SLACK_BLOCK_LIMIT) {
+    // Slack rejects payloads with more than 50 blocks. Keep the first 49 and
+    // append a context note so long content degrades gracefully instead of
+    // failing the entire Block Kit payload with invalid_blocks.
+    const omitted = blocks.length - (SLACK_BLOCK_LIMIT - 1);
+    return [
+      ...blocks.slice(0, SLACK_BLOCK_LIMIT - 1),
+      {
+        type: "context",
+        elements: [
+          {
+            type: "mrkdwn",
+            text: `_${omitted} more block${omitted === 1 ? "" : "s"} omitted (Slack's ${SLACK_BLOCK_LIMIT}-block limit)._`,
+          },
+        ],
+      },
+    ];
+  }
+
   return blocks.length > 0 ? blocks : undefined;
 }
 
@@ -225,20 +224,22 @@ function splitIntoSegments(text: string): Segment[] {
 function parseTableRow(line: string): string[] {
   const ESCAPED_PIPE_PLACEHOLDER = "\x00PIPE\x00";
   const ESCAPED_BACKSLASH_PLACEHOLDER = "\x00BSLASH\x00";
-  return line
-    // First, protect escaped backslashes (\\) so they don't interfere
-    .replace(/\\\\/g, ESCAPED_BACKSLASH_PLACEHOLDER)
-    // Now a remaining \| is a genuinely escaped pipe (odd backslash)
-    .replace(/\\\|/g, ESCAPED_PIPE_PLACEHOLDER)
-    .replace(/^\|/, "")
-    .replace(/\|$/, "")
-    .split("|")
-    .map((cell) =>
-      cell
-        .replaceAll(ESCAPED_PIPE_PLACEHOLDER, "|")
-        .replaceAll(ESCAPED_BACKSLASH_PLACEHOLDER, "\\\\")
-        .trim(),
-    );
+  return (
+    line
+      // First, protect escaped backslashes (\\) so they don't interfere
+      .replace(/\\\\/g, ESCAPED_BACKSLASH_PLACEHOLDER)
+      // Now a remaining \| is a genuinely escaped pipe (odd backslash)
+      .replace(/\\\|/g, ESCAPED_PIPE_PLACEHOLDER)
+      .replace(/^\|/, "")
+      .replace(/\|$/, "")
+      .split("|")
+      .map((cell) =>
+        cell
+          .replaceAll(ESCAPED_PIPE_PLACEHOLDER, "|")
+          .replaceAll(ESCAPED_BACKSLASH_PLACEHOLDER, "\\\\")
+          .trim(),
+      )
+  );
 }
 
 /**
@@ -488,10 +489,7 @@ function computeMrkdwnSpans(window: string): Array<[number, number]> {
   return intervals;
 }
 
-function isInsideSpan(
-  pos: number,
-  spans: Array<[number, number]>,
-): boolean {
+function isInsideSpan(pos: number, spans: Array<[number, number]>): boolean {
   for (const [start, end] of spans) {
     if (pos > start && pos < end) return true;
   }