@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/persistence/migrations/363-backfill-schedule-inference-profile.test.ts

@@ -0,0 +1,229 @@
+import { Database } from "bun:sqlite";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import {
+  type DurableProfileFields,
+  resolveDurableProfile,
+} from "../conversation-crud.js";
+
+// The migration resolves through the shared schedule helpers, which read the
+// workspace config. The default is stubbed so both of its outcomes can be
+// driven: a named profile, and the code-owned anchor (null), which has no key
+// to record. The wake seed keeps the real durable-pin reader so the
+// session-backed vs. sticky distinction under test is the production one.
+let resolvedDefault: string | null = "balanced";
+mock.module("../../schedule/inference-profile.js", () => ({
+  resolveDefaultScheduleInferenceProfile: () => resolvedDefault,
+  resolveWakeScheduleInferenceProfile: (target: DurableProfileFields | null) =>
+    resolveDurableProfile(target) ?? resolvedDefault,
+}));
+
+import * as schema from "../schema.js";
+import { migrateBackfillScheduleInferenceProfile } from "./363-backfill-schedule-inference-profile.js";
+
+function createTestDb(withProfileColumn = true) {
+  const sqlite = new Database(":memory:");
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE cron_jobs (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      message TEXT NOT NULL,
+      next_run_at INTEGER NOT NULL,
+      mode TEXT NOT NULL DEFAULT 'execute',
+      wake_conversation_id TEXT${withProfileColumn ? ",\n      inference_profile TEXT" : ""}
+    );
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      conversation_type TEXT,
+      inference_profile TEXT,
+      inference_profile_session_id TEXT,
+      inference_profile_expires_at INTEGER
+    );
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function insertJob(
+  sqlite: Database,
+  id: string,
+  inferenceProfile: string | null,
+): void {
+  sqlite
+    .query(
+      "INSERT INTO cron_jobs (id, name, message, next_run_at, inference_profile) VALUES (?, ?, ?, ?, ?)",
+    )
+    .run(id, id, "hi", 1000, inferenceProfile);
+}
+
+function insertWakeJob(
+  sqlite: Database,
+  id: string,
+  wakeConversationId: string,
+): void {
+  sqlite
+    .query(
+      "INSERT INTO cron_jobs (id, name, message, next_run_at, mode, wake_conversation_id, inference_profile) VALUES (?, ?, ?, ?, 'wake', ?, NULL)",
+    )
+    .run(id, id, "hi", 1000, wakeConversationId);
+}
+
+function insertConversation(
+  sqlite: Database,
+  id: string,
+  fields: {
+    inferenceProfile?: string | null;
+    sessionId?: string | null;
+    expiresAt?: number | null;
+  } = {},
+): void {
+  sqlite
+    .query(
+      "INSERT INTO conversations (id, conversation_type, inference_profile, inference_profile_session_id, inference_profile_expires_at) VALUES (?, 'chat', ?, ?, ?)",
+    )
+    .run(
+      id,
+      fields.inferenceProfile ?? null,
+      fields.sessionId ?? null,
+      fields.expiresAt ?? null,
+    );
+}
+
+function profileOf(sqlite: Database, id: string): unknown {
+  return (
+    sqlite
+      .query("SELECT inference_profile FROM cron_jobs WHERE id = ?")
+      .get(id) as { inference_profile: unknown }
+  ).inference_profile;
+}
+
+describe("migration 363: backfill cron_jobs.inference_profile", () => {
+  beforeEach(() => {
+    resolvedDefault = "balanced";
+  });
+
+  test("pins unpinned rows to the resolved default", () => {
+    const { sqlite, db } = createTestDb();
+    insertJob(sqlite, "unpinned-1", null);
+    insertJob(sqlite, "unpinned-2", null);
+
+    migrateBackfillScheduleInferenceProfile(db);
+
+    expect(profileOf(sqlite, "unpinned-1")).toBe("balanced");
+    expect(profileOf(sqlite, "unpinned-2")).toBe("balanced");
+  });
+
+  test("leaves an existing pin alone", () => {
+    const { sqlite, db } = createTestDb();
+    insertJob(sqlite, "pinned", "cost-optimized");
+
+    migrateBackfillScheduleInferenceProfile(db);
+
+    expect(profileOf(sqlite, "pinned")).toBe("cost-optimized");
+  });
+
+  test("is idempotent: a second run changes nothing", () => {
+    const { sqlite, db } = createTestDb();
+    insertJob(sqlite, "unpinned", null);
+
+    migrateBackfillScheduleInferenceProfile(db);
+    resolvedDefault = "cost-optimized";
+    migrateBackfillScheduleInferenceProfile(db);
+
+    // The row was pinned by the first run, so the later default does not
+    // overwrite it. That is what makes a schedule's cost stable.
+    expect(profileOf(sqlite, "unpinned")).toBe("balanced");
+  });
+
+  test("leaves rows null when no named profile resolves", () => {
+    const { sqlite, db } = createTestDb();
+    insertJob(sqlite, "unpinned", null);
+    resolvedDefault = null;
+
+    migrateBackfillScheduleInferenceProfile(db);
+
+    expect(profileOf(sqlite, "unpinned")).toBeNull();
+  });
+
+  test("skips an install that has no inference_profile column yet", () => {
+    const { sqlite, db } = createTestDb(false);
+    sqlite
+      .query(
+        "INSERT INTO cron_jobs (id, name, message, next_run_at) VALUES ('legacy', 'legacy', 'hi', 1000)",
+      )
+      .run();
+
+    expect(() => migrateBackfillScheduleInferenceProfile(db)).not.toThrow();
+  });
+
+  // A pending wake fires with no forced override today, so it resolves its
+  // target conversation's pin live. The backfill has to preserve that, or a
+  // reminder set inside a pinned conversation silently moves to the global
+  // default.
+  describe("wake rows seed from their target conversation", () => {
+    test("takes the target's durable pin", () => {
+      const { sqlite, db } = createTestDb();
+      insertConversation(sqlite, "conv-pinned", {
+        inferenceProfile: "cost-optimized",
+      });
+      insertWakeJob(sqlite, "wake-pinned", "conv-pinned");
+
+      migrateBackfillScheduleInferenceProfile(db);
+
+      expect(profileOf(sqlite, "wake-pinned")).toBe("cost-optimized");
+    });
+
+    test("takes the default when the target has no pin, as does an ordinary schedule", () => {
+      const { sqlite, db } = createTestDb();
+      insertConversation(sqlite, "conv-unpinned");
+      insertWakeJob(sqlite, "wake-unpinned", "conv-unpinned");
+      insertJob(sqlite, "ordinary", null);
+
+      migrateBackfillScheduleInferenceProfile(db);
+
+      expect(profileOf(sqlite, "wake-unpinned")).toBe("balanced");
+      expect(profileOf(sqlite, "ordinary")).toBe("balanced");
+    });
+
+    test("ignores a session-backed pin on the target", () => {
+      const { sqlite, db } = createTestDb();
+      insertConversation(sqlite, "conv-session", {
+        inferenceProfile: "cost-optimized",
+        sessionId: "session-1",
+        expiresAt: Date.now() + 600_000,
+      });
+      insertWakeJob(sqlite, "wake-session", "conv-session");
+
+      migrateBackfillScheduleInferenceProfile(db);
+
+      // The session lapses in minutes; the row it seeded would keep billing
+      // that model for as long as the wake stays pending.
+      expect(profileOf(sqlite, "wake-session")).toBe("balanced");
+    });
+
+    test("takes the default when the target conversation is gone", () => {
+      const { sqlite, db } = createTestDb();
+      insertWakeJob(sqlite, "wake-orphan", "conv-deleted");
+
+      migrateBackfillScheduleInferenceProfile(db);
+
+      expect(profileOf(sqlite, "wake-orphan")).toBe("balanced");
+    });
+
+    test("keeps the target's pin even when no default resolves", () => {
+      const { sqlite, db } = createTestDb();
+      resolvedDefault = null;
+      insertConversation(sqlite, "conv-pinned", {
+        inferenceProfile: "cost-optimized",
+      });
+      insertWakeJob(sqlite, "wake-pinned", "conv-pinned");
+      insertJob(sqlite, "ordinary", null);
+
+      migrateBackfillScheduleInferenceProfile(db);
+
+      expect(profileOf(sqlite, "wake-pinned")).toBe("cost-optimized");
+      expect(profileOf(sqlite, "ordinary")).toBeNull();
+    });
+  });
+});

package/src/persistence/migrations/363-backfill-schedule-inference-profile.ts

@@ -0,0 +1,127 @@
+import type { Database } from "bun:sqlite";
+
+import {
+  resolveDefaultScheduleInferenceProfile,
+  resolveWakeScheduleInferenceProfile,
+} from "../../schedule/inference-profile.js";
+import type { DurableProfileFields } from "../conversation-crud.js";
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/** Columns a wake row's seed needs on `cron_jobs` and `conversations`. */
+const WAKE_JOB_COLUMNS = ["mode", "wake_conversation_id"] as const;
+const CONVERSATION_PIN_COLUMNS = [
+  "conversation_type",
+  "inference_profile",
+  "inference_profile_session_id",
+  "inference_profile_expires_at",
+] as const;
+
+function hasColumns(
+  raw: Database,
+  table: string,
+  required: readonly string[],
+): boolean {
+  const columns = raw.prepare(`PRAGMA table_info(${table})`).all() as {
+    name: string;
+  }[];
+  const present = new Set(columns.map((c) => c.name));
+  return required.every((name) => present.has(name));
+}
+
+/**
+ * Pin every unpinned schedule to a concrete inference profile.
+ *
+ * A schedule with no pin follows `llm.activeProfile`, so changing the global
+ * default silently moves every such schedule onto a different model and a
+ * different price. Schedules created from now on snapshot a profile at write
+ * time (`insertSchedule`); this backfill gives the rows that predate that the
+ * same stability, on the profile they are running under today.
+ *
+ * "Running under today" is not the global default for every row. An unpinned
+ * wake row reaches `buildWakeScheduleOptions` with no forced override, so its
+ * firing resolves the target conversation's own pin live. Stamping the global
+ * default over it would silently re-point a pending reminder that was created
+ * inside a pinned conversation, so wake rows seed through the same
+ * {@link resolveWakeScheduleInferenceProfile} the create path uses: the
+ * target's durable pin, else the default. Every other row takes the default.
+ *
+ * Rows keep a NULL pin when no named profile resolves at all (the winner is
+ * the code-owned anchor). That is the same value they carry now and resolves
+ * identically at run time, through the `mainAgent` call-site configuration.
+ *
+ * Only `cron_jobs` is written. `conversations` carries a pin the user sets per
+ * conversation (read here, never modified), and the telemetry tables
+ * (tool_invocations, llm_usage_events, skill_loaded_events) carry an
+ * `inference_profile` recording what actually ran, which must keep its
+ * historical value.
+ *
+ * Idempotent: `WHERE inference_profile IS NULL` matches nothing once a row is
+ * pinned, and the PRAGMA guards skip an install that has not created the
+ * columns yet.
+ */
+export function migrateBackfillScheduleInferenceProfile(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+  if (!hasColumns(raw, "cron_jobs", ["inference_profile"])) {
+    return;
+  }
+
+  if (
+    hasColumns(raw, "cron_jobs", WAKE_JOB_COLUMNS) &&
+    hasColumns(raw, "conversations", CONVERSATION_PIN_COLUMNS)
+  ) {
+    backfillWakeRows(raw);
+  }
+
+  const profile = resolveDefaultScheduleInferenceProfile();
+  if (profile === null) {
+    return;
+  }
+  raw
+    .prepare(
+      `UPDATE cron_jobs SET inference_profile = ? WHERE inference_profile IS NULL`,
+    )
+    .run(profile);
+}
+
+function backfillWakeRows(raw: Database): void {
+  const rows = raw
+    .prepare(
+      `SELECT id, wake_conversation_id AS wakeConversationId
+         FROM cron_jobs
+        WHERE inference_profile IS NULL
+          AND mode = 'wake'
+          AND wake_conversation_id IS NOT NULL`,
+    )
+    .all() as { id: string; wakeConversationId: string }[];
+  if (rows.length === 0) {
+    return;
+  }
+
+  const selectTarget = raw.prepare(
+    `SELECT conversation_type AS conversationType,
+            inference_profile AS inferenceProfile,
+            inference_profile_session_id AS inferenceProfileSessionId,
+            inference_profile_expires_at AS inferenceProfileExpiresAt
+       FROM conversations
+      WHERE id = ?`,
+  );
+  const pin = raw.prepare(
+    `UPDATE cron_jobs SET inference_profile = ? WHERE id = ? AND inference_profile IS NULL`,
+  );
+
+  for (const row of rows) {
+    // A target deleted since the wake was created reads as null and falls
+    // through to the default, the same value the firing would resolve.
+    const target =
+      (selectTarget.get(
+        row.wakeConversationId,
+      ) as DurableProfileFields | null) ?? null;
+    const profile = resolveWakeScheduleInferenceProfile(target);
+    if (profile === null) {
+      continue;
+    }
+    pin.run(profile, row.id);
+  }
+}

package/src/persistence/migrations/364-add-schedule-source-key.test.ts

@@ -0,0 +1,120 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateAddScheduleSourceKey } from "./364-add-schedule-source-key.js";
+
+const NEW_COLUMNS = ["source_key", "definition_hash", "user_enabled"];
+
+/** Pre-364 shape: the cron_jobs table exactly as core tables created it. */
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec(/*sql*/ `
+    CREATE TABLE cron_jobs (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      cron_expression TEXT NOT NULL,
+      schedule_syntax TEXT NOT NULL DEFAULT 'cron',
+      timezone TEXT,
+      message TEXT NOT NULL,
+      next_run_at INTEGER NOT NULL,
+      last_run_at INTEGER,
+      last_status TEXT,
+      retry_count INTEGER NOT NULL DEFAULT 0,
+      created_by TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function columnInfo(sqlite: Database) {
+  return sqlite.query("PRAGMA table_info(cron_jobs)").all() as Array<{
+    name: string;
+    notnull: number;
+  }>;
+}
+
+function insertJob(
+  sqlite: Database,
+  id: string,
+  sourceKey: string | null,
+): void {
+  sqlite
+    .query(
+      /*sql*/ `INSERT INTO cron_jobs (id, name, cron_expression, message, next_run_at, created_by, created_at, updated_at, source_key)
+       VALUES (?, 'Job', '0 9 * * *', 'hello', 1000, 'agent', 1000, 1000, ?)`,
+    )
+    .run(id, sourceKey);
+}
+
+describe("migration 364: cron_jobs declaration provenance", () => {
+  test("adds the nullable columns to an existing database", () => {
+    const { sqlite, db } = createTestDb();
+    const before = columnInfo(sqlite).map((c) => c.name);
+    for (const name of NEW_COLUMNS) {
+      expect(before).not.toContain(name);
+    }
+
+    migrateAddScheduleSourceKey(db);
+
+    const after = columnInfo(sqlite);
+    for (const name of NEW_COLUMNS) {
+      const column = after.find((c) => c.name === name);
+      expect(column).toBeDefined();
+      expect(column?.notnull).toBe(0);
+    }
+  });
+
+  test("rows written before the columns existed read back null", () => {
+    const { sqlite, db } = createTestDb();
+    sqlite.exec(/*sql*/ `
+      INSERT INTO cron_jobs (id, name, cron_expression, message, next_run_at, created_by, created_at, updated_at)
+      VALUES ('job-old', 'Old', '0 9 * * *', 'hello', 1000, 'agent', 1000, 1000)
+    `);
+
+    migrateAddScheduleSourceKey(db);
+
+    const row = sqlite
+      .query(
+        "SELECT source_key, definition_hash, user_enabled FROM cron_jobs WHERE id = 'job-old'",
+      )
+      .get() as Record<string, unknown>;
+    expect(row.source_key).toBeNull();
+    expect(row.definition_hash).toBeNull();
+    expect(row.user_enabled).toBeNull();
+  });
+
+  test("rejects a second row with the same source_key", () => {
+    const { sqlite, db } = createTestDb();
+    migrateAddScheduleSourceKey(db);
+
+    insertJob(sqlite, "job-a", "plugin:example/daily");
+
+    expect(() => insertJob(sqlite, "job-b", "plugin:example/daily")).toThrow();
+  });
+
+  test("leaves imperative schedules unconstrained", () => {
+    const { sqlite, db } = createTestDb();
+    migrateAddScheduleSourceKey(db);
+
+    insertJob(sqlite, "job-a", null);
+    expect(() => insertJob(sqlite, "job-b", null)).not.toThrow();
+  });
+
+  test("is idempotent: re-run is a no-op", () => {
+    const { sqlite, db } = createTestDb();
+
+    migrateAddScheduleSourceKey(db);
+    expect(() => migrateAddScheduleSourceKey(db)).not.toThrow();
+
+    const names = columnInfo(sqlite).map((c) => c.name);
+    for (const name of NEW_COLUMNS) {
+      expect(names.filter((n) => n === name)).toHaveLength(1);
+    }
+  });
+});

package/src/persistence/migrations/364-add-schedule-source-key.ts

@@ -0,0 +1,43 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+
+const COLUMNS: ReadonlyArray<{ name: string; definition: string }> = [
+  { name: "source_key", definition: "source_key TEXT" },
+  { name: "definition_hash", definition: "definition_hash TEXT" },
+  { name: "user_enabled", definition: "user_enabled INTEGER" },
+];
+
+/**
+ * Add plugin-declaration provenance columns to `cron_jobs`.
+ *
+ * `source_key` links a schedule row to the plugin declaration it was
+ * reconciled from (`plugin:<pluginName>/<scheduleName>`). Rows with a NULL
+ * `source_key` are imperative schedules and keep their existing behavior.
+ * `definition_hash` is the reconciler's change detector over the declaration
+ * files. `user_enabled` is the user's enable/disable override for a sourced
+ * row; NULL means the declaration's own enabled value applies.
+ *
+ * The unique index is partial (`WHERE source_key IS NOT NULL`) so the many
+ * NULL rows stay unconstrained while a given declaration resolves to exactly
+ * one row. The reconciler's upsert depends on that uniqueness.
+ *
+ * Nullable with no backfill: nothing recorded declaration provenance before
+ * these columns existed, so pre-existing rows correctly stay NULL.
+ *
+ * Idempotent: each column add is guarded with `tableHasColumn` and the index
+ * with `IF NOT EXISTS`, so a crash partway through does not break the next
+ * boot.
+ */
+export function migrateAddScheduleSourceKey(database: DrizzleDb): void {
+  for (const column of COLUMNS) {
+    if (!tableHasColumn(database, "cron_jobs", column.name)) {
+      database.run(`ALTER TABLE cron_jobs ADD COLUMN ${column.definition}`);
+    }
+  }
+
+  database.run(/*sql*/ `
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_cron_jobs_source_key
+    ON cron_jobs(source_key)
+    WHERE source_key IS NOT NULL
+  `);
+}

package/src/persistence/migrations/365-add-conversation-fork-strategy.ts

@@ -0,0 +1,27 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+
+/**
+ * Add `fork_strategy` to `conversations`, the discriminator that says whether
+ * a fork's inherited history lives on the fork (copied) or on its parent
+ * (read through `fork_parent_message_id`).
+ *
+ * The column is required even though `fork_parent_conversation_id` and
+ * `fork_parent_message_id` already exist, because both are set on copied
+ * forks too. Without a discriminator, a lineage read cannot tell a fork whose
+ * prefix it must fetch from the parent from one that already holds its own
+ * copy of that prefix, and would return the copied rows twice.
+ *
+ * Nullable with no backfill: every fork that exists when this runs was
+ * materialized by copying, and `isReferentialFork` reads NULL as `cloning`.
+ * A backfill would have to write a value to every historical conversation row
+ * to encode what the absence of a value already means.
+ *
+ * Idempotent: the column add is guarded with `tableHasColumn`, so a crash
+ * partway through does not break the next boot.
+ */
+export function migrateAddConversationForkStrategy(database: DrizzleDb): void {
+  if (!tableHasColumn(database, "conversations", "fork_strategy")) {
+    database.run(`ALTER TABLE conversations ADD COLUMN fork_strategy TEXT`);
+  }
+}

package/src/persistence/schema/conversations.ts

@@ -37,6 +37,16 @@ export const conversations = sqliteTable(
     originInterface: text("origin_interface"),
     forkParentConversationId: text("fork_parent_conversation_id"),
     forkParentMessageId: text("fork_parent_message_id"),
+    /**
+     * How this conversation's fork was materialized: `reference` means the
+     * rows at-or-before `forkParentMessageId` live on the parent and are read
+     * through it, `cloning` (and NULL, the value every pre-existing fork
+     * carries) means they were physically copied onto this row. Read through
+     * `isReferentialFork` in `conversation-lineage.ts`, never directly: the
+     * NULL-is-cloning default is what keeps existing forks from being read
+     * twice, once from their copies and once through their parent.
+     */
+    forkStrategy: text("fork_strategy"),
     /**
      * Id of the conversation that spawned this one (subagent spawns stamp
      * their parent's conversation id). Distinct from
@@ -45,6 +55,28 @@ export const conversations = sqliteTable(
      * conversations not spawned by another conversation.
      */
     parentConversationId: text("parent_conversation_id"),
+    /**
+     * Role the subagent that owns this conversation was spawned with, from
+     * `SUBAGENT_ROLE_REGISTRY` (`researcher`, `builder`, `advisor`); a spawn
+     * that named no role records the default, `builder`. NULL for every
+     * conversation that is not a subagent.
+     *
+     * Denormalized here rather than read from the `subagents` table at
+     * telemetry-flush time on purpose: `subagents` rows are deleted on
+     * dispose (TTL sweep ~30 minutes after the run goes terminal), while
+     * usage telemetry flushes on a watermark that can trail arbitrarily far
+     * behind after an ingest outage. Stamping the conversation row, the same
+     * rationale that put `parent_conversation_id` here, makes the
+     * attribution durable for the life of the usage row.
+     */
+    subagentRole: text("subagent_role"),
+    /**
+     * How the subagent that owns this conversation was spawned: context
+     * inheritance and lifecycle, orthogonal to {@link subagentRole}. One of
+     * the modes described on `SubagentSpawnMode` in `subagent/types.ts`. NULL
+     * for every conversation that is not a subagent.
+     */
+    subagentSpawnMode: text("subagent_spawn_mode"),
     isAutoTitle: integer("is_auto_title").notNull().default(1),
     scheduleJobId: text("schedule_job_id"),
     lastMessageAt: integer("last_message_at"),

package/src/persistence/schema/infrastructure.ts

@@ -40,6 +40,9 @@ export const cronJobs = sqliteTable("cron_jobs", {
   workflowName: text("workflow_name"), // saved workflow to trigger (nullable, only used when mode = 'workflow')
   workflowArgsJson: text("workflow_args_json"), // JSON-encoded args passed to the workflow run (nullable)
   capabilitiesJson: text("capabilities_json"), // JSON-encoded capability manifest for the run (nullable; null = hardcoded read-only manifest)
+  sourceKey: text("source_key"), // plugin declaration key ('plugin:<pluginName>/<scheduleName>'); null = imperative schedule
+  definitionHash: text("definition_hash"), // reconciler change detector over the declaration files (nullable, only used when source_key is set)
+  userEnabled: integer("user_enabled", { mode: "boolean" }), // user override for a sourced row's enabled state; null = declaration's value applies
   createdAt: integer("created_at").notNull(),
   updatedAt: integer("updated_at").notNull(),
 });

package/src/persistence/steps.ts

@@ -468,6 +468,11 @@ import { migrateMoveMemorySegmentsToMemoryDb } from "./migrations/357-move-memor
 import { migrateMoveMemoryEmbeddingsToMemoryDb } from "./migrations/358-move-memory-embeddings-to-memory-db.js";
 import { migrateMoveMemorySummariesToMemoryDb } from "./migrations/359-move-memory-summaries-to-memory-db.js";
 import { migrateAddDocumentWorkspacePath } from "./migrations/360-add-document-workspace-path.js";
+import { migrateNormalizeManagedConnectionRows } from "./migrations/361-normalize-managed-connection-rows.js";
+import { migrateAddConversationSubagentKind } from "./migrations/362-add-conversation-subagent-kind.js";
+import { migrateBackfillScheduleInferenceProfile } from "./migrations/363-backfill-schedule-inference-profile.js";
+import { migrateAddScheduleSourceKey } from "./migrations/364-add-schedule-source-key.js";
+import { migrateAddConversationForkStrategy } from "./migrations/365-add-conversation-fork-strategy.js";
 import type { MigrationStep } from "./migrations/run-migrations.js";
 
 export const migrationSteps: MigrationStep[] = [
@@ -1543,4 +1548,29 @@ export const migrationSteps: MigrationStep[] = [
     ],
   },
   migrateAddDocumentWorkspacePath,
+  {
+    name: "migrateNormalizeManagedConnectionRows",
+    run: migrateNormalizeManagedConnectionRows,
+    // The table-exists guard treats a missing table as nothing-to-do, so
+    // without this dependency a failed table creation followed by repair
+    // would permanently checkpoint the normalization as a no-op.
+    dependsOn: ["migrateCreateProviderConnections"],
+  },
+  {
+    name: "migrateAddConversationSubagentKind",
+    run: migrateAddConversationSubagentKind,
+    // The backfill reads the `subagents` table (migration 311), so that table
+    // must exist and be checkpointed first.
+    dependsOn: ["migrateCreateSubagentsTable"],
+  },
+  {
+    name: "migrateBackfillScheduleInferenceProfile",
+    run: migrateBackfillScheduleInferenceProfile,
+    // The column-exists guard treats a missing column as nothing-to-do, so
+    // without this dependency a failed column add followed by repair would
+    // permanently checkpoint the backfill as a no-op.
+    dependsOn: ["migrateScheduleInferenceProfile"],
+  },
+  migrateAddScheduleSourceKey,
+  migrateAddConversationForkStrategy,
 ];