@vellumai/assistant 0.8.5 → 0.8.6

package/src/runtime/routes/inbound-stages/background-dispatch.ts

@@ -11,7 +11,11 @@ import type { ChannelId, InterfaceId } from "../../../channels/types.js";
 import { findGuardianForChannel } from "../../../contacts/contact-store.js";
 import type { ServerMessage } from "../../../daemon/message-protocol.js";
 import type { TrustContext } from "../../../daemon/trust-context.js";
-import { updateDeliveredSegmentCount } from "../../../memory/delivery-channels.js";
+import {
+  addSlackDmLiveDeliveredTextResponseIndex,
+  getSlackDmLiveDeliveredTextResponseIndexes,
+  updateDeliveredSegmentCount,
+} from "../../../memory/delivery-channels.js";
 import {
   linkMessage,
   storeReplyMessageId,
@@ -44,6 +48,10 @@ import type {
   MessageProcessor,
   SlackInboundMessageMetadata,
 } from "../../http-types.js";
+import {
+  createSlackDmTextDeliveryController,
+  isSlackDeliveryCallbackUrl,
+} from "../../slack-dm-text-delivery.js";
 import { resolveRoutingState } from "../../trust-context-resolver.js";
 import { deliverReplyViaCallback } from "../channel-delivery-routes.js";
 import { deliverGeneratedApprovalPrompt } from "../guardian-approval-prompt.js";
@@ -228,6 +236,21 @@ export function processChannelMessageInBackground(
             }
           : undefined;
       let replyMessageId: string | undefined;
+      const slackDmTextDelivery = createSlackDmTextDeliveryController({
+        sourceChannel,
+        chatType,
+        replyCallbackUrl,
+        chatId: externalChatId,
+        assistantId,
+        deliveredTextResponseIndexes:
+          getSlackDmLiveDeliveredTextResponseIndexes(eventId),
+        onTextResponseDelivered: (responseIndex, reason) => {
+          addSlackDmLiveDeliveredTextResponseIndex(eventId, responseIndex);
+          if (reason === "before_tool") {
+            slackThinkingStatus?.refreshAfterReply();
+          }
+        },
+      });
       const observeAgentEvent = (msg: ServerMessage): void => {
         if (
           msg.type === "message_complete" &&
@@ -236,6 +259,7 @@ export function processChannelMessageInBackground(
         ) {
           replyMessageId = msg.messageId;
         }
+        slackDmTextDelivery?.observeEvent(msg);
         slackThinkingStatus?.observeEvent(msg);
       };
 
@@ -297,12 +321,21 @@ export function processChannelMessageInBackground(
           { err, conversationId },
           "Background channel message processing failed",
         );
+        if (slackDmTextDelivery) {
+          await slackDmTextDelivery.waitForPendingDeliveries();
+        }
         recordProcessingFailure(eventId, err);
         return;
       }
 
       if (replyCallbackUrl) {
         try {
+          if (slackDmTextDelivery) {
+            await slackDmTextDelivery.waitForPendingDeliveries();
+          }
+          const liveDeliveryResumeOptions =
+            slackDmTextDelivery?.getFinalDeliveryResumeOptions(replyMessageId);
+
           await deliverReplyViaCallback(
             conversationId,
             externalChatId,
@@ -311,6 +344,7 @@ export function processChannelMessageInBackground(
             {
               messageId: replyMessageId,
               sinceMessageId: userMessageId,
+              ...liveDeliveryResumeOptions,
               onSegmentDelivered: (count) =>
                 updateDeliveredSegmentCount(eventId, count),
             },
@@ -395,11 +429,13 @@ function startTelegramTypingHeartbeat(
 
 type SlackThinkingStatusController = {
   observeEvent: (msg: ServerMessage) => void;
+  refreshAfterReply: () => void;
   stop: () => void;
 };
 
 type SlackThinkingStatusHandle = {
   updateLoadingMessages: (loadingMessages?: string[]) => void;
+  refresh: (loadingMessages?: string[]) => void;
   clear: () => void;
 };
 
@@ -440,12 +476,9 @@ function shouldEmitSlackThinkingStatus(
   sourceChannel: ChannelId,
   replyCallbackUrl?: string,
 ): boolean {
-  if (sourceChannel !== "slack" || !replyCallbackUrl) return false;
-  try {
-    return new URL(replyCallbackUrl).pathname.endsWith("/deliver/slack");
-  } catch {
-    return replyCallbackUrl.endsWith("/deliver/slack");
-  }
+  return (
+    sourceChannel === "slack" && isSlackDeliveryCallbackUrl(replyCallbackUrl)
+  );
 }
 
 export function shouldStartSlackThinkingStatusImmediately(params: {
@@ -547,6 +580,13 @@ function createSlackThinkingStatusController(params: {
         start();
       }
     },
+    refreshAfterReply() {
+      if (stopped || !slackThinkingStatus) return;
+      // Slack clears assistant thread status when the app sends a reply, so
+      // live pre-tool replies need to reassert it while work continues.
+      slackThinkingStatus.refresh(currentLoadingMessages);
+      lastSentLoadingMessageKey = getLoadingMessagesKey(currentLoadingMessages);
+    },
     stop() {
       stopped = true;
       slackThinkingStatus?.clear();
@@ -627,7 +667,9 @@ function getTaskProgressLoadingMessage(
 
   const activeStep = progress.steps[activeStepIndex]!;
   return [
-    `In progress (${activeStepIndex + 1}/${progress.steps.length}): ${activeStep.label}`,
+    `In progress (${activeStepIndex + 1}/${progress.steps.length}): ${
+      activeStep.label
+    }`,
   ];
 }
 
@@ -656,6 +698,7 @@ function setSlackThinkingStatus(
     if (!messageTs) {
       return {
         updateLoadingMessages: () => {},
+        refresh: () => {},
         clear: () => {},
       };
     }
@@ -697,6 +740,7 @@ function setSlackThinkingStatus(
 
     return {
       updateLoadingMessages: () => {},
+      refresh: () => {},
       clear: clearReaction,
     };
   }
@@ -739,6 +783,10 @@ function setSlackThinkingStatus(
     );
   };
 
+  const refresh = (nextLoadingMessages?: string[]): void => {
+    updateLoadingMessages(nextLoadingMessages);
+  };
+
   const clearStatus = (): void => {
     if (cleared) return;
     cleared = true;
@@ -766,6 +814,7 @@ function setSlackThinkingStatus(
 
   return {
     updateLoadingMessages,
+    refresh,
     clear: clearStatus,
   };
 }

package/src/runtime/routes/index.ts

@@ -40,6 +40,7 @@ import { ROUTES as CONTENT_SOURCE_ROUTES } from "./content-source-routes.js";
 import { ROUTES as CONVERSATION_ANALYSIS_ROUTES } from "./conversation-analysis-routes.js";
 import { ROUTES as CONVERSATION_ATTENTION_ROUTES } from "./conversation-attention-routes.js";
 import { ROUTES as CONVERSATION_CLI_ROUTES } from "./conversation-cli-routes.js";
+import { ROUTES as CONVERSATION_COMPACTION_ROUTES } from "./conversation-compaction-routes.js";
 import { ROUTES as CONVERSATION_LIST_ROUTES } from "./conversation-list-routes.js";
 import { ROUTES as CONVERSATION_MANAGEMENT_ROUTES } from "./conversation-management-routes.js";
 import { ROUTES as CONVERSATION_QUERY_ROUTES } from "./conversation-query-routes.js";
@@ -179,6 +180,7 @@ export const ROUTES: RouteDefinition[] = [
   ...CREDENTIAL_PROMPT_ROUTES,
   ...CREDENTIAL_ROUTES,
   ...DEFER_ROUTES,
+  ...CONVERSATION_COMPACTION_ROUTES,
   ...CONVERSATION_QUERY_ROUTES,
   ...CONVERSATION_STARTER_ROUTES,
   ...DEBUG_BASH_ROUTES,

package/src/runtime/routes/inference-provider-connection-routes.ts

@@ -4,7 +4,7 @@
  * GET    /v1/inference/provider-connections          — list all connections (optional ?provider= filter)
  * GET    /v1/inference/provider-connections/:name    — single connection by name
  * POST   /v1/inference/provider-connections          — create a new connection
- * PATCH  /v1/inference/provider-connections/:name    — update auth/label/status (cannot rename or change provider; auth is locked to platform for managed connections)
+ * PATCH  /v1/inference/provider-connections/:name    — update auth/label (cannot rename or change provider; auth is locked to platform for managed connections)
  * DELETE /v1/inference/provider-connections/:name    — delete (rejects if profiles or call sites reference it; rejects outright for managed connections)
  */
 
@@ -18,7 +18,6 @@ import {
   type ConnectionModel,
   ConnectionModelSchema,
   ConnectionProviderSchema,
-  ConnectionStatusSchema,
   ProviderConnectionSchema,
   VALID_CONNECTION_PROVIDERS,
 } from "../../providers/inference/auth.js";
@@ -223,14 +222,6 @@ async function handleCreateConnection({ body = {} }: RouteHandlerArgs) {
     throw new BadRequestError(`Invalid auth: ${authResult.error.message}`);
   }
 
-  const statusResult =
-    body.status !== undefined
-      ? ConnectionStatusSchema.safeParse(body.status)
-      : null;
-  if (statusResult && !statusResult.success) {
-    throw new BadRequestError(`Invalid status: must be "active" or "disabled"`);
-  }
-
   const labelRaw = body.label;
   if (
     labelRaw !== undefined &&
@@ -248,7 +239,6 @@ async function handleCreateConnection({ body = {} }: RouteHandlerArgs) {
     name,
     provider: providerResult.data,
     auth: authResult.data,
-    ...(statusResult ? { status: statusResult.data } : {}),
     ...(labelRaw !== undefined ? { label: labelRaw as string | null } : {}),
     ...customFields,
   });
@@ -302,14 +292,6 @@ async function handleUpdateConnection({
     throw new BadRequestError(`Invalid auth: ${authResult.error.message}`);
   }
 
-  const statusResult =
-    body.status !== undefined
-      ? ConnectionStatusSchema.safeParse(body.status)
-      : null;
-  if (statusResult && !statusResult.success) {
-    throw new BadRequestError(`Invalid status: must be "active" or "disabled"`);
-  }
-
   const labelRaw = body.label;
   if (
     labelRaw !== undefined &&
@@ -323,8 +305,8 @@ async function handleUpdateConnection({
 
   // Managed connections: lock auth to `{type:"platform"}`. The boot upsert in
   // `seedCanonicalConnections` would revert any other value on next restart;
-  // reject the write here so the surprise loop never happens. Label and status
-  // remain user-editable (the boot upsert leaves those alone).
+  // reject the write here so the surprise loop never happens. Label remains
+  // user-editable (the boot upsert leaves it alone).
   if (
     MANAGED_CONNECTION_NAMES.has(name) &&
     authResult.data.type !== "platform"
@@ -338,7 +320,6 @@ async function handleUpdateConnection({
 
   const result = updateConnection(getDb(), name, {
     auth: authResult.data,
-    ...(statusResult ? { status: statusResult.data } : {}),
     ...(labelRaw !== undefined ? { label: labelRaw as string | null } : {}),
     ...customFields,
   });
@@ -387,7 +368,7 @@ function handleDeleteConnection({ pathParams = {} }: RouteHandlerArgs) {
   // re-overlaid by `seed-inference-profiles.ts` on boot).
   if (MANAGED_CONNECTION_NAMES.has(name)) {
     throw new BadRequestError(
-      `Cannot delete managed connection "${name}". This is a Vellum-managed connection — disable it via PATCH status="disabled" if you want to opt out of platform inference.`,
+      `Cannot delete managed connection "${name}". This is a Vellum-managed connection that is re-seeded on every startup.`,
     );
   }
 
@@ -485,7 +466,6 @@ export const ROUTES: RouteDefinition[] = [
       provider: ConnectionProviderSchema,
       auth: AuthSchema,
       label: z.string().min(1).optional(),
-      status: ConnectionStatusSchema.optional(),
       base_url: z.string().url().nullable().optional(),
       models: z.array(ConnectionModelSchema).nullable().optional(),
     }),
@@ -504,12 +484,11 @@ export const ROUTES: RouteDefinition[] = [
     policyKey: "inference/provider-connections/detail",
     summary: "Update a provider connection",
     description:
-      "Update an existing connection. Cannot rename or change the provider. For managed connections (anthropic-managed, openai-managed, gemini-managed) the auth is locked to platform; label and status remain editable.",
+      "Update an existing connection. Cannot rename or change the provider. For managed connections (anthropic-managed, openai-managed, gemini-managed) the auth is locked to platform; label remains editable.",
     tags: ["inference"],
     pathParams: [{ name: "name", description: "Connection name" }],
     requestBody: z.object({
       auth: AuthSchema,
-      status: ConnectionStatusSchema.optional(),
       label: z.string().min(1).nullable().optional(),
       base_url: z.string().url().nullable().optional(),
       models: z.array(ConnectionModelSchema).nullable().optional(),

package/src/runtime/routes/integrations/vercel.ts

@@ -9,6 +9,8 @@
  * ("set" or "delete") rather than using HTTP verbs directly.
  */
 
+import { z } from "zod";
+
 import {
   deleteVercelConfig,
   getVercelConfig,
@@ -17,6 +19,12 @@ import {
 import { BadRequestError } from "../errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "../types.js";
 
+const vercelConfigResponseSchema = z.object({
+  hasToken: z.boolean(),
+  success: z.boolean(),
+  error: z.string().optional(),
+});
+
 // ---------------------------------------------------------------------------
 // Handlers
 // ---------------------------------------------------------------------------
@@ -66,6 +74,7 @@ export const ROUTES: RouteDefinition[] = [
     description: "Check if a Vercel API token is stored.",
     tags: ["integrations"],
     requirePolicyEnforcement: true,
+    responseBody: vercelConfigResponseSchema,
     handler: () => handleGetVercelConfig(),
   },
   {
@@ -77,6 +86,11 @@ export const ROUTES: RouteDefinition[] = [
       "Set or delete the Vercel API token. Action is determined by the body action field.",
     tags: ["integrations"],
     requirePolicyEnforcement: true,
+    requestBody: z.object({
+      action: z.enum(["get", "set", "delete"]).optional(),
+      apiToken: z.string().optional(),
+    }),
+    responseBody: vercelConfigResponseSchema,
     handler: handlePostVercelConfig,
   },
   {
@@ -87,6 +101,7 @@ export const ROUTES: RouteDefinition[] = [
     description: "Delete the stored Vercel API token.",
     tags: ["integrations"],
     requirePolicyEnforcement: true,
+    responseBody: vercelConfigResponseSchema,
     handler: () => handleDeleteVercelConfig(),
   },
 ];

package/src/runtime/routes/llm-context-normalization.ts

@@ -1057,8 +1057,13 @@ function extractOpenAiResponsesRequestToolNames(tools: unknown): string[] {
       if (asString(tool.type) === "function" && asString(tool.name)) {
         return asString(tool.name);
       }
-      // Native web search tool: { type: "web_search_preview" }
-      if (asString(tool.type) === "web_search_preview") {
+      // Native web search tools:
+      // - OpenAI API: { type: "web_search_preview" }
+      // - Codex subscription endpoint: { type: "web_search" }
+      if (
+        asString(tool.type) === "web_search_preview" ||
+        asString(tool.type) === "web_search"
+      ) {
         return "web_search";
       }
       return undefined;

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

@@ -22,14 +22,27 @@ 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 { readActivationLogsForShadowDiff } from "../../memory/memory-v2-activation-log-store.js";
 import type {
   RetrievalCost,
   RetrievalInput,
 } from "../../memory/v2/harness/retriever.js";
 import type { DescentTrace } from "../../memory/v2/harness/trace.js";
 import { loadNowText } from "../../memory/v2/now-text.js";
+import {
+  DEFAULT_SEED_OPTIONS,
+  seedCoretrievalEdges,
+  type SeedCoretrievalResult,
+} from "../../memory/v3/coretrieval-seed.js";
 import type { LlmCallRecord } from "../../memory/v3/llm-capture.js";
 import { runRetrievalLoop } from "../../memory/v3/loop.js";
+import type {
+  ShadowDiffResult,
+  ShadowDiffTurn,
+  SlugFrequency,
+  UnpairedShadowTurn,
+} from "../../memory/v3/shadow-diff.js";
+import { computeShadowDiff } from "../../memory/v3/shadow-diff.js";
 import { getTreeIndex } from "../../memory/v3/tree-index.js";
 import type { TreeValidationReport } from "../../memory/v3/validate.js";
 import { validateTree } from "../../memory/v3/validate.js";
@@ -49,6 +62,13 @@ export type {
   TreeLevel,
 } from "../../memory/v2/harness/trace.js";
 export type { LlmCallRecord };
+export type {
+  ShadowDiffResult,
+  ShadowDiffTurn,
+  SlugFrequency,
+  UnpairedShadowTurn,
+};
+export type { SeedCoretrievalResult };
 
 // ── Validate ────────────────────────────────────────────────────────────
 
@@ -119,7 +139,7 @@ async function handleTree({
 /** The five v3 retrieval lanes, in fanout order. */
 const V3_LANE_NAMES = ["hot", "sparse", "dense", "tree", "edges"] as const;
 
-const MemoryV3SimulateParams = z
+export const MemoryV3SimulateParams = z
   .object({
     /** The ad-hoc user query to route a single synthetic turn against. */
     query: z.string().min(1, "memory.v3.simulate query must be non-empty"),
@@ -138,7 +158,10 @@ const MemoryV3SimulateParams = z
      * Restrict the run to this allowlist of lanes (others forced off). Omit to
      * inherit the live `memory.v3.lanes` toggles.
      */
-    lanes: z.array(z.enum(V3_LANE_NAMES)).optional(),
+    lanes: z
+      .array(z.enum(V3_LANE_NAMES))
+      .min(1, "memory.v3.simulate lanes must list at least one lane")
+      .optional(),
   })
   .strict();
 
@@ -276,6 +299,118 @@ async function handleSimulate({
   };
 }
 
+// ── Shadow-diff ─────────────────────────────────────────────────────────
+
+/** Default pairing tolerance: a shadow row + its router sibling land ~1-2s apart. */
+const DEFAULT_SHADOW_DIFF_TOLERANCE_SEC = 10;
+/** Default cap on per-turn detail rows returned (aggregates are unbounded). */
+const DEFAULT_SHADOW_DIFF_LIMIT = 50;
+/** Milliseconds per day, for the `sinceDays` read-window cutoff. */
+const MS_PER_DAY = 86_400_000;
+
+const MemoryV3ShadowDiffParams = z
+  .object({
+    /** Only consider shadow rows newer than this many days. Omit for all rows. */
+    sinceDays: z
+      .number()
+      .positive("memory.v3.shadow-diff sinceDays must be positive")
+      .optional(),
+    /** Max |Δt| (seconds) to pair a shadow row with a router row. */
+    toleranceSec: z
+      .number()
+      .positive("memory.v3.shadow-diff toleranceSec must be positive")
+      .optional(),
+    /** Cap on per-turn detail rows in the response (newest first). */
+    limit: z
+      .number()
+      .int("memory.v3.shadow-diff limit must be an integer")
+      .positive("memory.v3.shadow-diff limit must be positive")
+      .optional(),
+  })
+  .strict();
+
+/**
+ * Compare the v3 shadow selections against the live v2 router selections,
+ * turn-for-turn, from the activation log. Read-only: reads `v3_shadow` rows and
+ * the `router` rows they pair with (bounded to those conversations + time
+ * span), then diffs each pair. Requires v3 shadow mode to have been running
+ * (`memory.v3.enabled` + `.shadow`) so the `v3_shadow` rows exist; the route
+ * itself runs no LLM and writes nothing.
+ */
+async function handleShadowDiff({
+  body = {},
+}: RouteHandlerArgs): Promise<ShadowDiffResult> {
+  const { sinceDays, toleranceSec, limit } =
+    MemoryV3ShadowDiffParams.parse(body);
+
+  const sinceMs =
+    sinceDays !== undefined ? Date.now() - sinceDays * MS_PER_DAY : null;
+  const toleranceMs =
+    (toleranceSec ?? DEFAULT_SHADOW_DIFF_TOLERANCE_SEC) * 1000;
+
+  const { shadow, router } = readActivationLogsForShadowDiff({
+    sinceMs,
+    paddingMs: toleranceMs,
+  });
+
+  return computeShadowDiff(shadow, router, {
+    toleranceMs,
+    detailLimit: limit ?? DEFAULT_SHADOW_DIFF_LIMIT,
+  });
+}
+
+// ── Seed co-retrieval edges ───────────────────────────────────────────────
+
+const MemoryV3SeedEdgesParams = z
+  .object({
+    /** A pair must co-occur on at least this many router turns to earn an edge. */
+    minCount: z
+      .number()
+      .int("memory.v3.seed-edges minCount must be an integer")
+      .positive("memory.v3.seed-edges minCount must be positive")
+      .optional(),
+    /** Neighbors kept per source node, ranked by NPMI descending. */
+    topK: z
+      .number()
+      .int("memory.v3.seed-edges topK must be an integer")
+      .positive("memory.v3.seed-edges topK must be positive")
+      .optional(),
+    /** Exclude neighbors selected on more than this fraction of all turns. */
+    maxNeighborFreqRatio: z
+      .number()
+      .positive("memory.v3.seed-edges maxNeighborFreqRatio must be positive")
+      .max(1, "memory.v3.seed-edges maxNeighborFreqRatio must be <= 1")
+      .optional(),
+    /** Flat weight each seeded edge is written at. */
+    seedWeight: z
+      .number()
+      .positive("memory.v3.seed-edges seedWeight must be positive")
+      .optional(),
+  })
+  .strict();
+
+/**
+ * Build the co-retrieval graph from the v2 router's selection history and
+ * persist it into `memory_v3_auto_edges`. This is the one write surface among
+ * the v3 routes — it warm-starts the learned edge graph that the edge-expansion
+ * lane merges (when `memory.v3.edges.learnedAdjacencyThreshold > 0`). Idempotent:
+ * re-running upserts each seeded edge to the flat seed weight without unbounded
+ * growth. Runs no LLM.
+ */
+async function handleSeedEdges({
+  body = {},
+}: RouteHandlerArgs): Promise<SeedCoretrievalResult> {
+  const { minCount, topK, maxNeighborFreqRatio, seedWeight } =
+    MemoryV3SeedEdgesParams.parse(body);
+  return seedCoretrievalEdges(getDb(), {
+    minCount: minCount ?? DEFAULT_SEED_OPTIONS.minCount,
+    topK: topK ?? DEFAULT_SEED_OPTIONS.topK,
+    maxNeighborFreqRatio:
+      maxNeighborFreqRatio ?? DEFAULT_SEED_OPTIONS.maxNeighborFreqRatio,
+    seedWeight: seedWeight ?? DEFAULT_SEED_OPTIONS.seedWeight,
+  });
+}
+
 // ── Route definitions ───────────────────────────────────────────────────
 
 export const ROUTES: RouteDefinition[] = [
@@ -313,4 +448,27 @@ export const ROUTES: RouteDefinition[] = [
     tags: ["memory"],
     requestBody: MemoryV3SimulateParams,
   },
+  {
+    operationId: "memory_v3_shadow_diff",
+    method: "POST",
+    endpoint: "memory/v3/shadow-diff",
+    handler: handleShadowDiff,
+    summary:
+      "Diff v3 shadow selections against live v2 router selections (read-only)",
+    description:
+      "Compares the v3 shadow-mode selections against the live v2 router selections turn-for-turn, from the memory activation log. Pairs each v3_shadow row with the nearest v2 router row in the same conversation (by timestamp, within a tolerance — the turn columns use different counters), then reports per-turn and aggregate overlap, what v3 surfaced that v2 did not, and what v2 had that v3 dropped, broken down by v3 provenance lane. The v2 comparand is the router's fresh per-turn pick (status='injected'), not its accumulated in-context set. Requires that v3 shadow mode has been running so v3_shadow rows exist; the route runs no LLM and writes nothing.",
+    tags: ["memory"],
+    requestBody: MemoryV3ShadowDiffParams,
+  },
+  {
+    operationId: "memory_v3_seed_edges",
+    method: "POST",
+    endpoint: "memory/v3/seed-edges",
+    handler: handleSeedEdges,
+    summary: "Seed the learned co-retrieval edge graph from v2 router history",
+    description:
+      "Builds an NPMI-scored co-retrieval graph from the v2 router's per-turn selections (memory_v2_activation_logs, status='injected') and persists it into memory_v3_auto_edges, warm-starting the learned edge graph that the v3 edge-expansion lane merges with curated edges when memory.v3.edges.learnedAdjacencyThreshold > 0. NPMI plus a min co-occurrence floor and an always-on frequency ceiling keep the neighborhoods associative rather than base-rate noise. Idempotent (upserts to a flat seed weight). Runs no LLM; the only write among the v3 routes.",
+    tags: ["memory"],
+    requestBody: MemoryV3SeedEdgesParams,
+  },
 ];

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

@@ -38,10 +38,7 @@ import {
   upsertCredentialMetadata,
 } from "../../tools/credentials/metadata-store.js";
 import { getLogger } from "../../util/logger.js";
-import {
-  getWorkspaceDir,
-  getWorkspaceHooksDir,
-} from "../../util/platform.js";
+import { getWorkspaceDir, getWorkspaceHooksDir } from "../../util/platform.js";
 import { APP_VERSION } from "../../version.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import {
@@ -358,11 +355,19 @@ export async function handleMigrationExport(
       checkpoint: async () => {
         // Dispatch through `runAsyncSqlite` so the WAL checkpoint runs
         // in a sqlite3 subprocess on hosts where it's available. A WAL
-        // truncate on a multi-GB WAL file can otherwise stall the
-        // daemon's event loop for the full duration of the flush.
-        const result = await runAsyncSqlite(
-          "PRAGMA wal_checkpoint(TRUNCATE)",
-        );
+        // 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): TRUNCATE has a side effect where, if the
+        // WAL is empty after the checkpoint, SQLite unlinks the WAL file
+        // from the directory. When the daemon's in-process connection
+        // still holds the original WAL fd, the unlink orphans that fd
+        // into a "ghost WAL" only the daemon can reach, and subsequent
+        // connections create a fresh WAL on disk — split-brain. FULL
+        // gives us the same flush-completion guarantee without the
+        // unlink side effect. See assistant/AGENTS.md "SQLite WAL
+        // checkpointing".
+        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
@@ -583,11 +588,13 @@ export async function handleMigrationExportToGcs({ body }: RouteHandlerArgs) {
           checkpoint: async () => {
             // Dispatch through `runAsyncSqlite` so the WAL checkpoint runs
             // in a sqlite3 subprocess on hosts where it's available. A
-            // WAL truncate on a multi-GB WAL file can otherwise stall the
+            // WAL flush on a multi-GB WAL file can otherwise stall the
             // daemon's event loop for the full duration of the flush.
-            const result = await runAsyncSqlite(
-              "PRAGMA wal_checkpoint(TRUNCATE)",
-            );
+            //
+            // 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 },