@vellumai/assistant 0.8.2 → 0.8.4

package/src/runtime/routes/memory-v2-routes.ts

@@ -8,6 +8,8 @@ import { join } from "node:path";
 import { z } from "zod";
 
 import { loadConfig } from "../../config/loader.js";
+import type { AssistantConfig } from "../../config/types.js";
+import { getDb } from "../../memory/db-connection.js";
 import {
   enqueueMemoryJob,
   type MemoryJobType,
@@ -21,12 +23,16 @@ import {
   totalEdgeCount,
   validateEdgeTargets,
 } from "../../memory/v2/edge-index.js";
+import { computeInjectionScores } from "../../memory/v2/injection-events.js";
+import { loadNowText } from "../../memory/v2/now-text.js";
+import { getPageIndex } from "../../memory/v2/page-index.js";
 import {
   getConceptsDir,
   listPages,
   readPage,
   renderPageContent,
 } from "../../memory/v2/page-store.js";
+import { type RouterSource, runRouter } from "../../memory/v2/router.js";
 import { seedV2SkillEntries } from "../../memory/v2/skill-store.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
@@ -290,6 +296,195 @@ async function handleConceptFrequency({
   return getConceptFrequencySummary(workspaceDir, { conversationId, sinceMs });
 }
 
+// ── EMA scores ──────────────────────────────────────────────────────────
+
+const MemoryV2EmaScoresParams = z.object({}).strict();
+
+export interface MemoryV2EmaScoresEntry {
+  slug: string;
+  /** Time-decayed injection frequency; 0 when no events in the read window. */
+  score: number;
+  /** File mtime in epoch ms; 0 for synthetic entries (skills, CLI commands). */
+  modifiedAt: number;
+}
+
+export interface MemoryV2EmaScoresResult {
+  /** Every page index entry, sorted by score descending then slug ASCII. */
+  entries: MemoryV2EmaScoresEntry[];
+}
+
+async function handleEmaScores({
+  body = {},
+}: RouteHandlerArgs): Promise<MemoryV2EmaScoresResult> {
+  // Intentionally NOT gated on `memory.v2.enabled` — operators inspecting
+  // EMA data before flipping tier-2 routing on is a legitimate dry-run
+  // use case, mirroring `memory_v2_validate`.
+  MemoryV2EmaScoresParams.parse(body);
+
+  const pageIndex = await getPageIndex(getWorkspaceDir());
+  const slugs = pageIndex.entries.map((e) => e.slug);
+  const scores = computeInjectionScores(getDb(), slugs, Date.now());
+
+  const entries: MemoryV2EmaScoresEntry[] = pageIndex.entries.map((entry) => ({
+    slug: entry.slug,
+    score: scores.get(entry.slug) ?? 0,
+    modifiedAt: entry.modifiedAt,
+  }));
+  entries.sort((a, b) => {
+    if (a.score !== b.score) return b.score - a.score;
+    return a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0;
+  });
+  return { entries };
+}
+
+// ── Simulate router (dry-run playground) ────────────────────────────────
+
+const SimulateRouterOverridesSchema = z
+  .object({
+    tier1_size: z.number().int().min(1).nullable().optional(),
+    tier2_size: z.number().int().min(1).nullable().optional(),
+    batch_size: z.number().int().min(1).nullable().optional(),
+  })
+  .strict();
+
+const MemoryV2SimulateRouterParams = z
+  .object({
+    query: z.string().min(1, "query must be non-empty"),
+    configOverrides: SimulateRouterOverridesSchema.optional(),
+  })
+  .strict();
+
+export interface MemoryV2SimulateRouterEffectiveConfig {
+  tier1_size: number | null;
+  tier2_size: number | null;
+  batch_size: number | null;
+  max_page_ids: number;
+}
+
+export interface MemoryV2SimulateRouterResult {
+  /** Slugs the router would select, in model-returned order. */
+  selectedSlugs: string[];
+  /** Per-slug provenance: `"tier1"`, `"tier2"`, or `"tier3:<bucket>"`. */
+  sourceBySlug: Record<string, RouterSource>;
+  /** EMA scores for the selected slugs (0 when the slug has no events). */
+  scores: Record<string, number>;
+  /** `null` on success; otherwise one of the router failure reasons. */
+  failureReason: string | null;
+  /** The router config that actually ran (live merged with overrides). */
+  effectiveConfig: MemoryV2SimulateRouterEffectiveConfig;
+  /** The overrides the caller submitted, for display. */
+  overrides: {
+    tier1_size?: number | null;
+    tier2_size?: number | null;
+    batch_size?: number | null;
+  };
+  /** Page index size the router was given (post-tier-carve, all batches). */
+  totalCandidatePages: number;
+}
+
+/**
+ * Build the config the router will see by overlaying override values on top
+ * of the live workspace config. Only the three new tier knobs are exposed —
+ * everything else (provider, prompts, weights) stays exactly as it would on
+ * a real turn. `undefined` means "inherit live"; `null` is a valid override
+ * value (meaning "disable this tier").
+ */
+function applySimulateOverrides(
+  live: AssistantConfig,
+  overrides: z.infer<typeof SimulateRouterOverridesSchema> | undefined,
+): AssistantConfig {
+  if (!overrides) return live;
+  const liveRouter = live.memory.v2.router;
+  const mergedRouter = {
+    ...liveRouter,
+    ...("tier1_size" in overrides && overrides.tier1_size !== undefined
+      ? { tier1_size: overrides.tier1_size }
+      : {}),
+    ...("tier2_size" in overrides && overrides.tier2_size !== undefined
+      ? { tier2_size: overrides.tier2_size }
+      : {}),
+    ...("batch_size" in overrides && overrides.batch_size !== undefined
+      ? { batch_size: overrides.batch_size }
+      : {}),
+  };
+  return {
+    ...live,
+    memory: {
+      ...live.memory,
+      v2: {
+        ...live.memory.v2,
+        router: mergedRouter,
+      },
+    },
+  };
+}
+
+export async function handleSimulateRouter({
+  body = {},
+}: RouteHandlerArgs): Promise<MemoryV2SimulateRouterResult> {
+  requireMemoryV2Enabled();
+  const { query, configOverrides } = MemoryV2SimulateRouterParams.parse(body);
+
+  const liveConfig = loadConfig();
+  const mergedConfig = applySimulateOverrides(liveConfig, configOverrides);
+  const effectiveRouter = mergedConfig.memory.v2.router;
+
+  const workspaceDir = getWorkspaceDir();
+  const nowText = await loadNowText(workspaceDir);
+
+  const routerResult = await runRouter({
+    workspaceDir,
+    userMessage: query,
+    assistantMessage: "",
+    nowText,
+    priorEverInjected: [],
+    config: mergedConfig,
+    database: getDb(),
+  });
+
+  const pageIndex = await getPageIndex(workspaceDir);
+  const scores = computeInjectionScores(
+    getDb(),
+    routerResult.selectedSlugs,
+    Date.now(),
+  );
+
+  const sourceBySlug: Record<string, RouterSource> = {};
+  for (const [slug, source] of routerResult.sourceBySlug.entries()) {
+    sourceBySlug[slug] = source;
+  }
+
+  const scoresOut: Record<string, number> = {};
+  for (const slug of routerResult.selectedSlugs) {
+    scoresOut[slug] = scores.get(slug) ?? 0;
+  }
+
+  return {
+    selectedSlugs: routerResult.selectedSlugs,
+    sourceBySlug,
+    scores: scoresOut,
+    failureReason: routerResult.failureReason,
+    effectiveConfig: {
+      tier1_size: effectiveRouter.tier1_size,
+      tier2_size: effectiveRouter.tier2_size,
+      batch_size: effectiveRouter.batch_size,
+      max_page_ids: effectiveRouter.max_page_ids,
+    },
+    overrides: {
+      ...(configOverrides?.tier1_size !== undefined
+        ? { tier1_size: configOverrides.tier1_size }
+        : {}),
+      ...(configOverrides?.tier2_size !== undefined
+        ? { tier2_size: configOverrides.tier2_size }
+        : {}),
+      ...(configOverrides?.batch_size !== undefined
+        ? { batch_size: configOverrides.batch_size }
+        : {}),
+    },
+    totalCandidatePages: pageIndex.entries.length,
+  };
+}
+
 // ── Route definitions ───────────────────────────────────────────────────
 
 export const ROUTES: RouteDefinition[] = [
@@ -359,4 +554,26 @@ export const ROUTES: RouteDefinition[] = [
     tags: ["memory"],
     requestBody: MemoryV2ConceptFrequencyParams,
   },
+  {
+    operationId: "memory_v2_ema_scores",
+    method: "POST",
+    endpoint: "memory/v2/ema-scores",
+    handler: handleEmaScores,
+    summary: "List every concept page with its injection-frequency EMA score",
+    description:
+      "Computes the time-decayed injection frequency (3-day half-life) for every entry in the current page index by reading memory_v2_injection_events. Returns entries sorted by score descending then slug ASCII, including zero-score pages so callers can decide whether to filter. Read-only; tier 2 of the v4 router uses the same computation to pick its top-M.",
+    tags: ["memory"],
+    requestBody: MemoryV2EmaScoresParams,
+  },
+  {
+    operationId: "memory_v2_simulate_router",
+    method: "POST",
+    endpoint: "memory/v2/simulate-router",
+    handler: handleSimulateRouter,
+    summary: "Dry-run the v4 router with config overrides (read-only)",
+    description:
+      "Runs the memory router against the live page index + EMA scores with optional tier_size / batch_size overrides, without recording an injection event or writing an activation log. Returns the slugs that would have been selected, per-slug tier provenance, EMA scores, and the effective router config so operators can validate knob changes before flipping them in workspace config.",
+    tags: ["memory"],
+    requestBody: MemoryV2SimulateRouterParams,
+  },
 ];

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

@@ -7,6 +7,7 @@ import { z } from "zod";
 
 import { getDb } from "../../memory/db-connection.js";
 import { notificationDeliveries } from "../../memory/schema.js";
+import { bufferIfDeferred } from "../../notifications/deferred-emit.js";
 import { emitNotificationSignal } from "../../notifications/emit-signal.js";
 import { listEvents } from "../../notifications/events-store.js";
 import type { AttentionHints } from "../../notifications/signal.js";
@@ -78,6 +79,9 @@ const EmitSignalParams = z.object({
   conversationAffinityHint: z.record(z.string(), z.string()).optional(),
   dedupeKey: z.string().optional(),
   throwOnError: z.boolean().optional(),
+  // Conversation that originated this signal — used by `deferred-emit` to
+  // buffer notifications during in-band background-job tool calls.
+  originatingConversationId: z.string().optional(),
 });
 
 const ListNotificationEventsParams = z.object({
@@ -89,7 +93,7 @@ const ListNotificationEventsParams = z.object({
 
 async function handleEmitSignal({ body = {} }: RouteHandlerArgs) {
   const validated = EmitSignalParams.parse(body);
-  const result = await emitNotificationSignal({
+  const params = {
     sourceEventName: validated.sourceEventName,
     sourceChannel: validated.sourceChannel,
     sourceContextId: validated.sourceContextId,
@@ -99,7 +103,20 @@ async function handleEmitSignal({ body = {} }: RouteHandlerArgs) {
     conversationAffinityHint: validated.conversationAffinityHint,
     dedupeKey: validated.dedupeKey,
     throwOnError: validated.throwOnError,
-  });
+  };
+  const buffered = bufferIfDeferred(
+    validated.originatingConversationId,
+    params,
+  );
+  if (buffered) {
+    return {
+      signalId: buffered.signalId,
+      dispatched: buffered.dispatched,
+      deduplicated: buffered.deduplicated,
+      reason: buffered.reason,
+    };
+  }
+  const result = await emitNotificationSignal(params);
   return {
     signalId: result.signalId,
     dispatched: result.dispatched,

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

@@ -148,7 +148,10 @@ function handleQuestionResponse({ body }: RouteHandlerArgs) {
 
   // Validation passed — deregister now to clear the prompter timer, then
   // hand the result to the prompter's caller via rpcResolve.
-  pendingInteractions.resolve(requestId);
+  pendingInteractions.resolve(
+    requestId,
+    response.kind === "close" ? "cancelled" : "answered",
+  );
 
   log.info(
     {

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

@@ -0,0 +1,159 @@
+/**
+ * Route definitions for Sanity CMS connection management.
+ *
+ * POST /v1/sanity/discover — project/dataset discovery using the stored API token
+ * POST /v1/sanity/connect  — finalise connection by writing the sidecar file
+ *
+ * Both routes use policyKey: "secrets" — they read credentials and write
+ * workspace data, the same policy tier as the existing secrets routes.
+ */
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { z } from "zod";
+
+import { credentialKey } from "../../security/credential-key.js";
+import { getSecureKeyAsync } from "../../security/secure-keys.js";
+import { getWorkspaceDir } from "../../util/platform.js";
+import { BadRequestError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+async function getStoredToken(): Promise<string | undefined> {
+  return getSecureKeyAsync(credentialKey("sanity", "api_token"));
+}
+
+function writeSidecar(relPath: string, data: Record<string, unknown>): void {
+  const workspaceDir = getWorkspaceDir();
+  const absPath = join(workspaceDir, relPath);
+  mkdirSync(dirname(absPath), { recursive: true });
+  writeFileSync(absPath, JSON.stringify(data, null, 2), "utf-8");
+}
+
+// ---------------------------------------------------------------------------
+// POST /v1/sanity/discover
+// ---------------------------------------------------------------------------
+
+async function handleDiscover(
+  args: RouteHandlerArgs,
+): Promise<Record<string, unknown>> {
+  const token = await getStoredToken();
+  if (!token) {
+    return { error: "no_token" };
+  }
+
+  const projectId =
+    typeof args.body?.projectId === "string" ? args.body.projectId : undefined;
+
+  if (!projectId) {
+    // List all projects this token has access to
+    const response = await fetch("https://api.sanity.io/v2021-06-07/projects", {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+
+    if (response.status === 401 || response.status === 403) {
+      return { error: "token_scope_limited" };
+    }
+
+    if (!response.ok) {
+      return { error: "discovery_failed" };
+    }
+
+    const raw = (await response.json()) as Array<{
+      id: string;
+      displayName?: string;
+    }>;
+    const projects = raw.map((p) => ({
+      id: p.id,
+      displayName: p.displayName ?? p.id,
+    }));
+    return { projects };
+  }
+
+  // List datasets for a specific project
+  const response = await fetch(
+    `https://api.sanity.io/v2021-06-07/projects/${projectId}/datasets`,
+    {
+      headers: { Authorization: `Bearer ${token}` },
+    },
+  );
+
+  if (response.status === 401 || response.status === 403) {
+    return { error: "token_scope_limited" };
+  }
+
+  if (!response.ok) {
+    return { error: "discovery_failed" };
+  }
+
+  const raw = (await response.json()) as Array<{ name: string }>;
+  const datasets = raw.map((d) => d.name);
+  return { projectId, datasets };
+}
+
+// ---------------------------------------------------------------------------
+// POST /v1/sanity/connect
+// ---------------------------------------------------------------------------
+
+async function handleConnect(
+  args: RouteHandlerArgs,
+): Promise<Record<string, unknown>> {
+  const token = await getStoredToken();
+  if (!token) {
+    throw new BadRequestError(
+      "Sanity API token not found. Store it first via POST /v1/secrets.",
+    );
+  }
+
+  const projectId =
+    typeof args.body?.projectId === "string" ? args.body.projectId.trim() : "";
+  const dataset =
+    typeof args.body?.dataset === "string" ? args.body.dataset.trim() : "";
+
+  if (!projectId) {
+    throw new BadRequestError(
+      "projectId is required and must be a non-empty string",
+    );
+  }
+  if (!dataset) {
+    throw new BadRequestError(
+      "dataset is required and must be a non-empty string",
+    );
+  }
+
+  writeSidecar("data/sanity-connection.json", { projectId, dataset });
+
+  return { ok: true };
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "sanity_discover",
+    endpoint: "sanity/discover",
+    method: "POST",
+    policyKey: "secrets",
+    summary: "Discover Sanity projects and datasets using the stored API token",
+    requestBody: z.object({ projectId: z.string().optional() }).optional(),
+    handler: handleDiscover,
+  },
+  {
+    operationId: "sanity_connect",
+    endpoint: "sanity/connect",
+    method: "POST",
+    policyKey: "secrets",
+    summary: "Finalise Sanity connection and write sidecar file",
+    requestBody: z.object({
+      projectId: z.string(),
+      dataset: z.string(),
+    }),
+    handler: handleConnect,
+  },
+];

package/src/runtime/routes/slack-channel-routes.ts

@@ -0,0 +1,187 @@
+import { z } from "zod";
+
+import {
+  conversationMetadataSyncTag,
+  SYNC_TAGS,
+} from "../../daemon/message-types/sync.js";
+import {
+  getBindingByConversation,
+  updateExternalChatName,
+} from "../../memory/external-conversation-store.js";
+import {
+  getSlackConversationInfo,
+  SlackApiError,
+} from "../../messaging/providers/slack/api.js";
+import { publishSyncInvalidation } from "../sync/sync-publisher.js";
+import { NotFoundError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+type ResolveReason =
+  | "auth"
+  | "dm"
+  | "no_name"
+  | "not_found"
+  | "permission"
+  | "rate_limit"
+  | "slack_error";
+
+interface SlackChannelResolveResponse {
+  channelId: string;
+  channelName?: string;
+  cached: boolean;
+  resolved: boolean;
+  reason?: ResolveReason;
+}
+
+const SlackChannelResolveResponseSchema = z.object({
+  channelId: z.string(),
+  channelName: z.string().optional(),
+  cached: z.boolean(),
+  resolved: z.boolean(),
+  reason: z
+    .enum([
+      "auth",
+      "dm",
+      "no_name",
+      "not_found",
+      "permission",
+      "rate_limit",
+      "slack_error",
+    ])
+    .optional(),
+});
+
+function friendlyCachedName(
+  externalChatId: string,
+  externalChatName?: string | null,
+): string | undefined {
+  const trimmed = externalChatName?.trim();
+  if (!trimmed || trimmed === externalChatId) return undefined;
+  return trimmed;
+}
+
+function usableResolvedName(
+  externalChatId: string,
+  name?: string,
+  nameNormalized?: string,
+): string | undefined {
+  for (const candidate of [name, nameNormalized]) {
+    const trimmed = candidate?.trim();
+    if (trimmed && trimmed !== externalChatId) return trimmed;
+  }
+  return undefined;
+}
+
+function reasonForSlackError(err: unknown): ResolveReason {
+  if (err instanceof SlackApiError) {
+    switch (err.category) {
+      case "auth":
+        return "auth";
+      case "channel_not_found":
+      case "not_found":
+        return "not_found";
+      case "permission":
+        return "permission";
+      case "rate_limit":
+        return "rate_limit";
+      default:
+        return "slack_error";
+    }
+  }
+  return "slack_error";
+}
+
+async function handleSlackChannelNameResolve({
+  pathParams = {},
+}: RouteHandlerArgs): Promise<SlackChannelResolveResponse> {
+  const conversationId = pathParams.conversationId?.trim();
+  if (!conversationId) {
+    throw new NotFoundError("Conversation not found");
+  }
+
+  const binding = getBindingByConversation(conversationId);
+
+  if (!binding || binding.sourceChannel !== "slack") {
+    throw new NotFoundError("Conversation not found");
+  }
+
+  const channelId = binding.externalChatId;
+  const cachedName = friendlyCachedName(channelId, binding.externalChatName);
+  if (cachedName) {
+    return {
+      channelId,
+      channelName: cachedName,
+      cached: true,
+      resolved: true,
+    };
+  }
+
+  if (channelId.startsWith("D")) {
+    return {
+      channelId,
+      cached: false,
+      resolved: false,
+      reason: "dm",
+    };
+  }
+
+  let info;
+  try {
+    info = await getSlackConversationInfo(channelId);
+  } catch (err) {
+    return {
+      channelId,
+      cached: false,
+      resolved: false,
+      reason: reasonForSlackError(err),
+    };
+  }
+
+  const channelName = usableResolvedName(
+    channelId,
+    info?.name,
+    info?.nameNormalized,
+  );
+  if (!channelName) {
+    return {
+      channelId,
+      cached: false,
+      resolved: false,
+      reason: "no_name",
+    };
+  }
+
+  updateExternalChatName(conversationId, channelName);
+  await publishSyncInvalidation([
+    SYNC_TAGS.conversationsList,
+    conversationMetadataSyncTag(conversationId),
+  ]);
+
+  return {
+    channelId,
+    channelName,
+    cached: false,
+    resolved: true,
+  };
+}
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "slack_channel_name_resolve",
+    endpoint: "conversations/:conversationId/slack-channel/resolve",
+    method: "POST",
+    handler: handleSlackChannelNameResolve,
+    summary: "Resolve Slack channel name",
+    description:
+      "Resolve and persist a friendly Slack channel name for an external conversation binding.",
+    tags: ["conversations", "slack"],
+    pathParams: [
+      {
+        name: "conversationId",
+        type: "string",
+        description: "Conversation ID whose Slack channel name should resolve.",
+      },
+    ],
+    responseBody: SlackChannelResolveResponseSchema,
+  },
+];

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

@@ -188,6 +188,47 @@ function getSubagentDetail(
 // ---------------------------------------------------------------------------
 
 export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "reconcileSubagents",
+    endpoint: "subagents/reconcile",
+    method: "GET",
+    policyKey: "subagents",
+    summary: "Reconcile subagent live status",
+    description:
+      "Returns the live in-memory status of all subagents known to the daemon for a given parent conversation. Subagents not in the response are orphaned.",
+    tags: ["subagents"],
+    queryParams: [
+      {
+        name: "parentConversationId",
+        schema: { type: "string" },
+        description: "Parent conversation ID",
+      },
+    ],
+    responseBody: z.object({
+      subagents: z.record(
+        z.string(),
+        z.object({
+          status: z.string(),
+        }),
+      ),
+    }),
+    handler: ({ queryParams }) => {
+      const parentConversationId = queryParams?.parentConversationId;
+      if (!parentConversationId) {
+        throw new BadRequestError(
+          "parentConversationId query parameter is required",
+        );
+      }
+      const manager = getSubagentManager();
+      const children = manager.getChildrenOf(parentConversationId);
+      const subagents: Record<string, { status: string }> = {};
+      for (const child of children) {
+        subagents[child.config.id] = { status: child.status };
+      }
+      return { subagents };
+    },
+  },
+
   {
     operationId: "getSubagentDetail",
     endpoint: "subagents/:id",