@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/memory/jobs-worker.ts

@@ -93,7 +93,6 @@ import {
   memoryV2ConsolidateJob,
 } from "./v2/consolidation-job.js";
 import { memoryV2SweepJob } from "./v2/sweep-job.js";
-import { spawnMemoryWorkerProcess } from "./worker-control.js";
 
 const log = getLogger("memory-jobs-worker");
 
@@ -162,64 +161,7 @@ export interface MemoryJobsWorker {
   stop(): void;
 }
 
-/**
- * Start the memory jobs worker using the configured implementation.
- *
- * `memory.worker.enabled` selects between two implementations:
- *   - enabled: spawn the worker as a separate OS process (the same path as
- *     `assistant memory worker start`), keeping long-running jobs off the
- *     caller's event loop.
- *   - disabled (default): run the worker in-process on the caller's event
- *     loop.
- *
- * The flag is read here so callers don't branch on it themselves. It only
- * governs which implementation starts; shutdown stops whichever worker is
- * actually running (see daemon/shutdown-handlers.ts), so the handle returned
- * for the out-of-process implementation has a no-op `stop()`.
- *
- * This dispatcher must not be used as the standalone worker process's entry —
- * that would recurse and fork-bomb. `worker-process.ts` calls
- * {@link startInProcessMemoryJobsWorker} directly.
- */
 export function startMemoryJobsWorker(): MemoryJobsWorker {
-  if (getConfig().memory.worker?.enabled === true) {
-    void spawnMemoryWorkerProcess()
-      .then(({ pid, alreadyRunning }) =>
-        log.info(
-          { pid, alreadyRunning },
-          alreadyRunning
-            ? "Memory worker process already running — reusing it"
-            : "Memory worker process started",
-        ),
-      )
-      .catch((err) =>
-        log.warn(
-          { err },
-          "Failed to start memory worker process — memory jobs will not be processed",
-        ),
-      );
-    return {
-      async runOnce(): Promise<number> {
-        return 0;
-      },
-      // No-op: shutdown always stops the worker process via the live-state
-      // PID probe in daemon/shutdown-handlers.ts, since it can't know whether
-      // the process was started here or out of band (e.g. `assistant memory
-      // worker start`) after boot.
-      stop(): void {},
-    };
-  }
-
-  return startInProcessMemoryJobsWorker();
-}
-
-/**
- * Run the memory jobs worker in-process on the caller's event loop: poll for
- * claimable jobs with adaptive backoff until {@link MemoryJobsWorker.stop} is
- * called. This is the worker loop itself — used directly by the daemon (when
- * `memory.worker.enabled` is off) and by the standalone worker process.
- */
-export function startInProcessMemoryJobsWorker(): MemoryJobsWorker {
   const recovered = resetRunningJobsToPending();
   if (recovered > 0) {
     log.info({ recovered }, "Recovered stale running memory jobs");

package/src/memory/llm-request-log-store.ts

@@ -94,21 +94,14 @@ export type CompactionAgentLogRow = LogMetaRow & {
  * can either stringify it directly (daemon-path `recordRequestLog`) or
  * store it on a pending-log queue that stringifies later (wake-path
  * `PendingLog.rawResponse`), without double-encoding.
- *
- * When the provider captured the verbatim upstream body, it is attached as a
- * top-level `rawResponse` sibling so the inspector's Raw tab can show the
- * actual provider payload (parsed JSON, or the raw string for non-JSON error
- * pages) — matching the success path, where Raw shows the real provider JSON.
  */
 export function buildProviderErrorResponsePayload(err: Error): {
   error: Record<string, unknown>;
-  rawResponse?: unknown;
 } {
   const payload: Record<string, unknown> = {
     name: err.name,
     message: err.message,
   };
-  let rawResponse: unknown;
   if (err instanceof ProviderError) {
     payload.code = err.code;
     payload.provider = err.provider;
@@ -118,28 +111,10 @@ export function buildProviderErrorResponsePayload(err: Error): {
     if (err.retryAfterMs !== undefined) {
       payload.retryAfterMs = err.retryAfterMs;
     }
-    if (err.apiErrorCode !== undefined) payload.apiErrorCode = err.apiErrorCode;
-    if (err.apiErrorType !== undefined) payload.apiErrorType = err.apiErrorType;
-    if (err.apiErrorParam !== undefined)
-      payload.apiErrorParam = err.apiErrorParam;
-    if (err.requestId !== undefined) payload.requestId = err.requestId;
-    if (err.rawBody !== undefined) rawResponse = parseRawBody(err.rawBody);
   } else if (err instanceof AssistantError) {
     payload.code = err.code;
   }
-  return rawResponse !== undefined
-    ? { error: payload, rawResponse }
-    : { error: payload };
-}
-
-/** Parse a captured upstream body as JSON, falling back to the raw string for
- *  non-JSON error pages (HTML, plain text) or a truncated/invalid prefix. */
-function parseRawBody(rawBody: string): unknown {
-  try {
-    return JSON.parse(rawBody);
-  } catch {
-    return rawBody;
-  }
+  return { error: payload };
 }
 
 export function recordRequestLog(

package/src/memory/llm-usage-store.ts

@@ -525,32 +525,7 @@ export function getUsageTotals(
   };
 }
 
-/**
- * Width of the SQL pre-aggregation bucket used by the time-series read paths,
- * in milliseconds. The series/daily endpoints bucket events into local-day or
- * local-hour buckets in JavaScript (SQLite's `strftime` is UTC-only and can't
- * honor an IANA timezone). To avoid materializing one JS object per usage event
- * — which on a 90-day window can mean hundreds of thousands of rows on the
- * daemon's main thread — we first roll events up in SQL into fixed UTC buckets,
- * then feed those far-fewer rows into the same JS bucketing logic.
- *
- * 15 minutes is the finest quantum every real-world IANA UTC offset divides
- * into (whole-hour offsets, plus the :30 and :45 zones like Asia/Kolkata and
- * Asia/Kathmandu). Because every local-day and local-hour boundary therefore
- * lands on a 15-minute UTC boundary, no pre-aggregation bucket can straddle a
- * local bucket boundary — so rolling up to 15-minute UTC buckets and then
- * re-bucketing in local time is exactly equal to bucketing each raw event.
- * DST fall-back hours stay distinct because their instants fall in different
- * 15-minute UTC buckets (and the JS layer disambiguates them by UTC offset).
- */
-const USAGE_PREAGG_BUCKET_MS = 15 * 60 * 1000;
-
-/**
- * Fetch usage rows for a time range, pre-aggregated into {@link
- * USAGE_PREAGG_BUCKET_MS} UTC buckets, for in-memory local-time bucketing. Each
- * returned row's `created_at` is its UTC bucket start, which the JS bucketing
- * maps to the same local bucket every raw event in that window would map to.
- */
+/** Fetch raw events in a time range for in-memory bucketing. */
 function fetchRawBucketRows(
   range: UsageTimeRange,
   filter?: UsageAggregationFilter,
@@ -559,14 +534,13 @@ function fetchRawBucketRows(
   return rawAll<UsageEventBucketRow>(
     /*sql*/ `
     SELECT
-      (created_at / ${USAGE_PREAGG_BUCKET_MS}) * ${USAGE_PREAGG_BUCKET_MS} AS created_at,
-      COALESCE(SUM(input_tokens), 0)                AS input_tokens,
-      COALESCE(SUM(output_tokens), 0)               AS output_tokens,
-      SUM(estimated_cost_usd)                       AS estimated_cost_usd,
-      SUM(COALESCE(llm_call_count, 1))              AS llm_call_count
+      created_at,
+      input_tokens,
+      output_tokens,
+      estimated_cost_usd,
+      llm_call_count
     FROM llm_usage_events
     WHERE ${where.sql}
-    GROUP BY (created_at / ${USAGE_PREAGG_BUCKET_MS})
     ORDER BY created_at ASC
     `,
     ...where.params,
@@ -855,18 +829,17 @@ export function getUsageGroupedSeries(
         WHERE ${where.sql}
       )
       SELECT
-        (schedule_usage.created_at / ${USAGE_PREAGG_BUCKET_MS}) * ${USAGE_PREAGG_BUCKET_MS} AS created_at,
-        COALESCE(SUM(schedule_usage.input_tokens), 0)            AS input_tokens,
-        COALESCE(SUM(schedule_usage.output_tokens), 0)           AS output_tokens,
-        SUM(schedule_usage.estimated_cost_usd)                   AS estimated_cost_usd,
-        SUM(COALESCE(schedule_usage.llm_call_count, 1))          AS llm_call_count,
-        schedule_usage.group_key                                 AS group_key,
-        MAX(schedule_group_jobs.name)                            AS group_label
+        schedule_usage.created_at,
+        schedule_usage.input_tokens,
+        schedule_usage.output_tokens,
+        schedule_usage.estimated_cost_usd,
+        schedule_usage.llm_call_count,
+        schedule_usage.group_key,
+        schedule_group_jobs.name AS group_label
       FROM schedule_usage
       LEFT JOIN cron_jobs schedule_group_jobs
         ON schedule_group_jobs.id = schedule_usage.group_key
-      GROUP BY (schedule_usage.created_at / ${USAGE_PREAGG_BUCKET_MS}), schedule_usage.group_key
-      ORDER BY created_at ASC
+      ORDER BY schedule_usage.created_at ASC
       `,
       ...groupKeySubquery.params,
       ...where.params,
@@ -877,16 +850,15 @@ export function getUsageGroupedSeries(
     rows = rawAll<UsageGroupedBucketRow>(
       /*sql*/ `
       SELECT
-        (e.created_at / ${USAGE_PREAGG_BUCKET_MS}) * ${USAGE_PREAGG_BUCKET_MS} AS created_at,
-        COALESCE(SUM(e.input_tokens), 0)             AS input_tokens,
-        COALESCE(SUM(e.output_tokens), 0)            AS output_tokens,
-        SUM(e.estimated_cost_usd)                    AS estimated_cost_usd,
-        SUM(COALESCE(e.llm_call_count, 1))           AS llm_call_count,
+        e.created_at,
+        e.input_tokens,
+        e.output_tokens,
+        e.estimated_cost_usd,
+        e.llm_call_count,
         e.${column} AS group_key
       FROM llm_usage_events e
       WHERE ${where.sql}
-      GROUP BY (e.created_at / ${USAGE_PREAGG_BUCKET_MS}), e.${column}
-      ORDER BY created_at ASC
+      ORDER BY e.created_at ASC
       `,
       ...where.params,
     );

package/src/memory/memory-retrospective-job.ts

@@ -44,6 +44,7 @@ import {
 } from "../channels/types.js";
 import type { AssistantConfig } from "../config/types.js";
 import { extractTurnContextTimestamp } from "../context/compactor.js";
+import { findConversation } from "../daemon/conversation-registry.js";
 import {
   formatLocalTimestamp,
   resolveTurnTimezoneContext,
@@ -62,7 +63,6 @@ import {
   forkConversationForRetrospective,
   getConversation,
   getMessagesAfter,
-  isConversationProcessing,
   resolveOverrideProfile,
 } from "./conversation-crud.js";
 import {
@@ -145,15 +145,14 @@ export async function runForkBasedRetrospective(
 
   // Forking mid-turn would capture a half-finished display turn — incremental
   // checkpoint persistence writes complete tool turns to the DB while the
-  // agent loop is still running. Check the persisted `processing_started_at`
-  // column (the cross-process source of truth) instead of the in-memory
-  // registry, so this guard works even when running in a separate CLI
-  // process with an empty conversation registry. Bump `lastRunAt` so the
-  // cooldown gate applies, leave `lastProcessedMessageId` untouched so the
-  // next interval/message-count trigger re-processes the same messages —
-  // nothing is lost. Returning (not throwing) keeps the jobs-worker from
+  // agent loop is still running. Peek the in-memory registry only (an
+  // unloaded conversation is by definition not processing); never load the
+  // conversation just to check. Bump `lastRunAt` so the cooldown gate
+  // applies, leave `lastProcessedMessageId` untouched so the next
+  // interval/message-count trigger re-processes the same messages — nothing
+  // is lost. Returning (not throwing) keeps the jobs-worker from
   // retry-with-backoff.
-  if (isConversationProcessing(sourceConversationId)) {
+  if (findConversation(sourceConversationId)?.isProcessing()) {
     bumpRetrospectiveLastRunAt(sourceConversationId, Date.now());
     log.info(
       { sourceConversationId },

package/src/memory/migrations/209-strip-thinking-from-consolidated.ts

@@ -1,86 +1,6 @@
-import { getLogger } from "../../util/logger.js";
-import { getDbPath } from "../../util/platform.js";
-import { runAsyncSqlite } from "../db-async-query.js";
 import type { DrizzleDb } from "../db-connection.js";
 import { getSqliteFrom } from "../db-connection.js";
 
-const log = getLogger("db-init");
-
-/**
- * Checkpoint key holding the highest `messages.rowid` already swept by this
- * migration. Persisted after every window so an interrupted run resumes from
- * where it left off instead of restarting the whole table scan. The value is a
- * plain integer string — deliberately not `started`/`rolling_back`, so
- * `recoverCrashedMigrations` never mistakes it for a stalled step and clears
- * it, and not `step:`-prefixed, so `validateMigrationState` ignores it.
- */
-const WATERMARK_KEY = "migration_209_strip_thinking_watermark";
-
-/**
- * Number of `rowid` values swept per `runAsyncSqlite` dispatch. Each window is
- * one off-thread subprocess transaction, so the size bounds both the WAL growth
- * per statement and how long a single write lock is held, while keeping the
- * number of subprocess spawns low on a large table.
- */
-const ROWID_WINDOW = 100_000;
-
-/** SQL predicate: this `json_each` element is an internal reasoning block. */
-const IS_THINKING = `json_extract(value, '$.type') IN ('thinking', 'redacted_thinking')`;
-
-/**
- * SQL predicate: this `json_each` element is kept. `IS NOT` (not `!=`) so a
- * block with a NULL/absent `type` is preserved, matching the JS filter the
- * original migration used (`b.type !== 'thinking'`).
- */
-const IS_KEPT = `json_extract(value, '$.type') IS NOT 'thinking' AND json_extract(value, '$.type') IS NOT 'redacted_thinking'`;
-
-/**
- * Build the two set-based UPDATEs that sweep one rowid window `(lo, hi]`.
- *
- *  - Statement A strips thinking/redacted_thinking blocks from rows that retain
- *    at least one kept block, rebuilding the content array in place. `json(value)`
- *    re-embeds each surviving element as JSON rather than a quoted string.
- *  - Statement B replaces all-thinking rows (no kept block survives) with the
- *    null-byte placeholder sentinel so the message isn't left empty. `char(0)`
- *    is evaluated inside SQLite, so the literal NUL is produced in the database
- *    and never written into the SQL piped to the sqlite3 CLI.
- *
- * Both are gated by a cheap `content LIKE '%thinking%'` substring prefilter
- * (covers both `thinking` and `redacted_thinking`) so the expensive `json_each`
- * work only runs for rows that could possibly contain a reasoning block. The
- * two statements touch disjoint row sets (A requires a kept block, B requires
- * none), so their order within the window is immaterial.
- */
-function windowSql(lo: number, hi: number): string {
-  const scope = `role = 'assistant'
-       AND rowid > ${lo} AND rowid <= ${hi}
-       AND content LIKE '%thinking%'
-       AND json_valid(content)
-       AND json_type(content) = 'array'`;
-
-  const stripMixed = /*sql*/ `
-    UPDATE messages
-    SET content = (
-      SELECT json_group_array(json(value))
-      FROM json_each(messages.content)
-      WHERE ${IS_KEPT}
-    )
-    WHERE ${scope}
-      AND EXISTS (SELECT 1 FROM json_each(messages.content) WHERE ${IS_THINKING})
-      AND EXISTS (SELECT 1 FROM json_each(messages.content) WHERE ${IS_KEPT});`;
-
-  const placeholderOnly = /*sql*/ `
-    UPDATE messages
-    SET content = json_array(
-      json_object('type', 'text', 'text', char(0) || '__PLACEHOLDER__[internal blocks omitted]')
-    )
-    WHERE ${scope}
-      AND EXISTS (SELECT 1 FROM json_each(messages.content) WHERE ${IS_THINKING})
-      AND NOT EXISTS (SELECT 1 FROM json_each(messages.content) WHERE ${IS_KEPT});`;
-
-  return `${stripMixed}\n${placeholderOnly}`;
-}
-
 /**
  * Strip thinking and redacted_thinking blocks from all assistant messages.
  *
@@ -91,62 +11,68 @@ function windowSql(lo: number, hi: number): string {
  * provider no longer needs to strip, enabling append-only conversation
  * history and stable prefix caching.
  *
- * The rewrite runs entirely inside SQLite (via JSON1), dispatched through
- * {@link runAsyncSqlite} a rowid window at a time. On a host with the `sqlite3`
- * CLI each window executes in a subprocess, leaving the daemon's event loop
- * free to answer `/healthz` while a multi-GB table is rewritten — the original
- * synchronous in-process loop blocked the loop for minutes and tripped the
- * startup probe into a restart loop. Progress is checkpointed per window, so an
- * interrupted run resumes instead of rescanning from the start.
- *
- * Idempotent — safe to re-run. Already-cleaned rows no longer contain a
- * thinking block, so the substring prefilter skips them.
+ * Idempotent — safe to re-run.
  */
-export async function migrateStripThinkingFromConsolidated(
+export function migrateStripThinkingFromConsolidated(
   database: DrizzleDb,
-): Promise<void> {
+): void {
   const raw = getSqliteFrom(database);
-  const dbPath = getDbPath();
-
-  const maxRow = (
-    raw.query(`SELECT MAX(rowid) AS m FROM messages`).get() as {
-      m: number | null;
-    }
-  ).m;
-  if (maxRow == null) return; // empty table — nothing to sweep
 
-  const watermarkRow = raw
-    .query(`SELECT value FROM memory_checkpoints WHERE key = ?`)
-    .get(WATERMARK_KEY) as { value: string } | undefined;
-  let lo = watermarkRow ? Number.parseInt(watermarkRow.value, 10) || 0 : 0;
-
-  const setWatermark = raw.query(
-    `INSERT OR REPLACE INTO memory_checkpoints (key, value, updated_at) VALUES (?, ?, ?)`,
-  );
-
-  while (lo < maxRow) {
-    const hi = Math.min(lo + ROWID_WINDOW, maxRow);
+  const BATCH_SIZE = 100;
+  let lastRowid = 0;
+
+  for (;;) {
+    const rows = raw
+      .query(
+        `SELECT rowid, id, content FROM messages
+         WHERE role = 'assistant'
+           AND rowid > ?
+         ORDER BY rowid
+         LIMIT ?`,
+      )
+      .all(lastRowid, BATCH_SIZE) as Array<{
+      rowid: number;
+      id: string;
+      content: string;
+    }>;
+
+    if (rows.length === 0) break;
+
+    for (const row of rows) {
+      lastRowid = row.rowid;
+
+      let blocks: Array<{ type: string }>;
+      try {
+        const parsed = JSON.parse(row.content);
+        if (!Array.isArray(parsed)) continue;
+        blocks = parsed;
+      } catch {
+        continue;
+      }
+
+      const hasThinking = blocks.some(
+        (b) => b.type === "thinking" || b.type === "redacted_thinking",
+      );
+      if (!hasThinking) continue;
 
-    const res = await runAsyncSqlite(windowSql(lo, hi), { dbPath });
-    if (!res.ok) {
-      // Leave the watermark at the last completed window; throwing reports the
-      // step failed so the runner retries it (from the watermark) next boot
-      // rather than checkpointing it as done.
-      throw new Error(
-        `strip-thinking window (${lo}, ${hi}] failed: ${res.error}`,
+      const stripped = blocks.filter(
+        (b) => b.type !== "thinking" && b.type !== "redacted_thinking",
       );
-    }
 
-    lo = hi;
-    setWatermark.run(WATERMARK_KEY, String(lo), Date.now());
+      // Preserve at least one block so the message isn't empty.
+      const finalContent =
+        stripped.length > 0
+          ? stripped
+          : [
+              {
+                type: "text" as const,
+                text: "\x00__PLACEHOLDER__[internal blocks omitted]",
+              },
+            ];
+
+      raw
+        .query(`UPDATE messages SET content = ? WHERE id = ?`)
+        .run(JSON.stringify(finalContent), row.id);
+    }
   }
-
-  // Bound WAL growth left by the windowed rewrites, then drop the watermark so
-  // a future re-run (e.g. after a rollback) starts clean.
-  await runAsyncSqlite(`PRAGMA wal_checkpoint(TRUNCATE);`, { dbPath });
-  raw.query(`DELETE FROM memory_checkpoints WHERE key = ?`).run(WATERMARK_KEY);
-
-  log.info(
-    "Migration 209: stripped thinking blocks from consolidated messages",
-  );
 }

package/src/memory/migrations/__tests__/run-migrations.test.ts

@@ -54,7 +54,7 @@ describe("runMigrationSteps — checkpointing", () => {
 
   test("records step completions in the shared memory_checkpoints ledger", async () => {
     /**
-     * Step bookkeeping lives in the same memory_checkpoints table the step runner
+     * Step bookkeeping lives in the same memory_checkpoints table the registry
      * uses, under the `step:` namespace — one ledger for all applied state.
      */
 
@@ -110,7 +110,7 @@ describe("runMigrationSteps — checkpointing", () => {
      * before the loop so a migration interrupted mid-flight re-runs this boot.
      */
 
-    // GIVEN a database with a stalled step checkpoint left by a crash
+    // GIVEN a database with a stalled registry checkpoint left by a crash
     const db = createTestDb();
     const raw = getSqliteFrom(db);
     raw.run(