@vellumai/assistant 0.11.2 → 0.11.3-dev.202608080427.92f668a

package/src/__tests__/schedule-store.test.ts

@@ -1,3 +1,5 @@
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { beforeEach, describe, expect, test } from "bun:test";
 import { mock } from "bun:test";
 
@@ -14,6 +16,11 @@ mock.module("../background-wake/publisher.js", () => ({
 
 import type { AssistantEventEnvelope } from "../api/index.js";
 import { SYNC_TAGS } from "../daemon/message-types/sync.js";
+import {
+  createConversation,
+  setConversationInferenceProfile,
+  setConversationInferenceProfileSession,
+} from "../persistence/conversation-crud.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
@@ -22,6 +29,8 @@ import {
   LEGACY_DEFER_CREATED_BY,
   OWNER_DEFER_CREATED_BY,
 } from "../schedule/defer-provenance.js";
+import { resolveDefaultScheduleInferenceProfile } from "../schedule/inference-profile.js";
+import type { DeclaredScheduleDefinition } from "../schedule/schedule-store.js";
 import {
   cancelSchedule,
   claimDueSchedules,
@@ -32,12 +41,17 @@ import {
   createScheduleRun,
   deleteSchedule,
   describeCronExpression,
+  disarmDeclaredSchedule,
   failOneShot,
   getSchedule,
+  listDeclaredSchedules,
   listSchedules,
+  setUserEnabled,
   updateSchedule,
+  upsertDeclaredSchedule,
 } from "../schedule/schedule-store.js";
 import { UserError } from "../util/errors.js";
+import { getWorkspacePluginsDir } from "../util/platform.js";
 
 await initializeDb();
 
@@ -1389,6 +1403,37 @@ describe("listSchedules new filters", () => {
     expect(conv123Only[0].name).toBe("Wake for conv-123");
     expect(conv123Only[0].wakeConversationId).toBe("conv-123");
   });
+
+  test("inferenceProfile filter returns only schedules pinned to that profile", async () => {
+    const defaultProfile = resolveDefaultScheduleInferenceProfile();
+    expect(defaultProfile).not.toBe("cost-optimized");
+
+    await createSchedule({
+      name: "Cheap digest",
+      message: "digest",
+      cronExpression: "0 * * * *",
+      inferenceProfile: "cost-optimized",
+    });
+    await createSchedule({
+      name: "Second cheap digest",
+      message: "digest",
+      cronExpression: "30 * * * *",
+      inferenceProfile: "cost-optimized",
+    });
+    await createSchedule({
+      name: "Default profile schedule",
+      message: "hi",
+      cronExpression: "0 9 * * *",
+    });
+
+    const cheapOnly = listSchedules({ inferenceProfile: "cost-optimized" });
+    expect(cheapOnly.map((j) => j.name).sort()).toEqual([
+      "Cheap digest",
+      "Second cheap digest",
+    ]);
+    expect(listSchedules({ inferenceProfile: "no-such-profile" })).toEqual([]);
+    expect(listSchedules().length).toBe(3);
+  });
 });
 
 // ── describeCronExpression ──────────────────────────────────────────
@@ -1506,3 +1551,498 @@ describe("owner-defer provenance", () => {
     expect(hasOwnerDeferProvenance(updated!.createdBy)).toBe(false);
   });
 });
+
+// ── Plugin-declared schedules ───────────────────────────────────────
+
+describe("declared schedules", () => {
+  const SOURCE_KEY = "plugin:example/daily";
+  const examplePluginDir = () => join(getWorkspacePluginsDir(), "example");
+
+  // setUserEnabled's enable path probes the declaration's on-disk presence
+  // and its plugin's manifest, so the suite keeps a declaration directory and
+  // a valid package.json in place for SOURCE_KEY; ghost-row tests remove them.
+  beforeEach(() => {
+    getDb().run("DELETE FROM cron_runs");
+    getDb().run("DELETE FROM cron_jobs");
+    rmSync(examplePluginDir(), { recursive: true, force: true });
+    const declarationDir = join(examplePluginDir(), "schedules", "daily");
+    mkdirSync(declarationDir, { recursive: true });
+    writeFileSync(
+      join(declarationDir, "config.json"),
+      JSON.stringify({ expression: "0 9 * * *" }),
+    );
+    writeFileSync(join(declarationDir, "index.md"), "produce the digest\n");
+    writeFileSync(
+      join(examplePluginDir(), "package.json"),
+      JSON.stringify({ name: "example", version: "1.0.0" }),
+    );
+  });
+
+  function makeDefinition(
+    overrides: Partial<DeclaredScheduleDefinition> = {},
+  ): DeclaredScheduleDefinition {
+    return {
+      name: "Daily digest",
+      description: "Summarize the day",
+      syntax: "cron",
+      expression: "0 9 * * *",
+      message: "produce the digest",
+      mode: "execute",
+      enabled: true,
+      definitionHash: "hash-1",
+      ...overrides,
+    };
+  }
+
+  function rawJob(id: string): Record<string, unknown> {
+    return getRawDb()
+      .query("SELECT * FROM cron_jobs WHERE id = ?")
+      .get(id) as Record<string, unknown>;
+  }
+
+  test("upsert inserts a sourced row with declared enabled state", async () => {
+    const job = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+
+    expect(job.sourceKey).toBe(SOURCE_KEY);
+    expect(job.definitionHash).toBe("hash-1");
+    expect(job.userEnabled).toBeNull();
+    expect(job.enabled).toBe(true);
+    expect(job.expression).toBe("0 9 * * *");
+    expect(job.nextRunAt).toBeGreaterThan(Date.now());
+  });
+
+  test("listDeclaredSchedules returns only sourced rows", async () => {
+    await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+    const imperative = await createSchedule({
+      name: "Mine",
+      cronExpression: "0 8 * * *",
+      message: "hello",
+      syntax: "cron",
+    });
+
+    const declared = listDeclaredSchedules();
+    expect(declared).toHaveLength(1);
+    expect(declared[0].sourceKey).toBe(SOURCE_KEY);
+    expect(imperative.sourceKey).toBeNull();
+    expect(imperative.definitionHash).toBeNull();
+    expect(imperative.userEnabled).toBeNull();
+  });
+
+  test("upsert with an unchanged hash is a no-op", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+    const before = rawJob(created.id);
+
+    const again = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+
+    expect(again.id).toBe(created.id);
+    expect(rawJob(created.id)).toEqual(before);
+  });
+
+  test("upsert with a changed hash updates definition columns without moving nextRunAt", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+
+    const updated = await upsertDeclaredSchedule(
+      SOURCE_KEY,
+      makeDefinition({
+        message: "produce a longer digest",
+        definitionHash: "hash-2",
+      }),
+    );
+
+    expect(updated.id).toBe(created.id);
+    expect(updated.message).toBe("produce a longer digest");
+    expect(updated.definitionHash).toBe("hash-2");
+    expect(updated.nextRunAt).toBe(created.nextRunAt);
+  });
+
+  test("upsert recomputes nextRunAt when the expression changes", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+
+    const updated = await upsertDeclaredSchedule(
+      SOURCE_KEY,
+      makeDefinition({ expression: "0 15 * * *", definitionHash: "hash-2" }),
+    );
+
+    expect(updated.expression).toBe("0 15 * * *");
+    expect(updated.nextRunAt).not.toBe(created.nextRunAt);
+    expect(updated.nextRunAt).toBeGreaterThan(Date.now());
+  });
+
+  test("upsert leaves engine-latched rows untouched", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+    // Recurrence exhaustion latch: the claim path disables the row, zeroes
+    // nextRunAt, and stamps lastRunAt in one write.
+    getRawDb().run(
+      "UPDATE cron_jobs SET enabled = 0, next_run_at = 0, last_run_at = ? WHERE id = ?",
+      [Date.now(), created.id],
+    );
+    const latched = rawJob(created.id);
+
+    await upsertDeclaredSchedule(
+      SOURCE_KEY,
+      makeDefinition({ definitionHash: "hash-2" }),
+    );
+
+    expect(rawJob(created.id)).toEqual(latched);
+  });
+
+  test("a declaration shipped disabled inserts disarmed and is not treated as latched", async () => {
+    const created = await upsertDeclaredSchedule(
+      SOURCE_KEY,
+      makeDefinition({ enabled: false }),
+    );
+    expect(created.enabled).toBe(false);
+    expect(created.nextRunAt).toBe(0);
+    expect(created.lastRunAt).toBeNull();
+
+    const armed = await upsertDeclaredSchedule(
+      SOURCE_KEY,
+      makeDefinition({ enabled: true, definitionHash: "hash-2" }),
+    );
+    expect(armed.enabled).toBe(true);
+    expect(armed.nextRunAt).toBeGreaterThan(Date.now());
+  });
+
+  test("disarm keeps the row and its runs; a later pass re-arms it", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+    const runId = await createScheduleRun(created.id, "conv-123");
+    await completeScheduleRun(runId, { status: "ok" });
+
+    await disarmDeclaredSchedule(created.id);
+
+    const disarmed = getSchedule(created.id);
+    expect(disarmed!.enabled).toBe(false);
+    const runs = getRawDb()
+      .query("SELECT COUNT(*) AS n FROM cron_runs WHERE job_id = ?")
+      .get(created.id) as { n: number };
+    expect(runs.n).toBe(1);
+
+    // Same declaration back in the desired set (e.g. plugin re-enabled):
+    // effective enabled is recomputed even though the hash matches.
+    const rearmed = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+    expect(rearmed.enabled).toBe(true);
+    expect(rearmed.nextRunAt).toBeGreaterThan(Date.now());
+  });
+
+  test("disarm refuses imperative rows", async () => {
+    const imperative = await createSchedule({
+      name: "Mine",
+      cronExpression: "0 8 * * *",
+      message: "hello",
+      syntax: "cron",
+    });
+
+    await expect(disarmDeclaredSchedule(imperative.id)).rejects.toThrow(
+      /plugin-sourced/,
+    );
+    expect(getSchedule(imperative.id)!.enabled).toBe(true);
+  });
+
+  test("user override wins over the declared value in both directions", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+
+    const off = await setUserEnabled(created.id, false);
+    expect(off!.userEnabled).toBe(false);
+    expect(off!.enabled).toBe(false);
+
+    // A reconcile pass with the declaration still enabled must not undo the
+    // user's override.
+    const afterPass = await upsertDeclaredSchedule(
+      SOURCE_KEY,
+      makeDefinition(),
+    );
+    expect(afterPass.enabled).toBe(false);
+    expect(afterPass.userEnabled).toBe(false);
+
+    const on = await setUserEnabled(created.id, true);
+    expect(on!.userEnabled).toBe(true);
+    expect(on!.enabled).toBe(true);
+    expect(on!.nextRunAt).toBeGreaterThan(Date.now());
+  });
+
+  test("setUserEnabled on an imperative row behaves like the existing toggle", async () => {
+    const imperative = await createSchedule({
+      name: "Mine",
+      cronExpression: "0 8 * * *",
+      message: "hello",
+      syntax: "cron",
+    });
+
+    const off = await setUserEnabled(imperative.id, false);
+    expect(off!.enabled).toBe(false);
+    expect(off!.userEnabled).toBeNull();
+    expect(off!.nextRunAt).toBe(0);
+
+    const on = await setUserEnabled(imperative.id, true);
+    expect(on!.enabled).toBe(true);
+    expect(on!.userEnabled).toBeNull();
+    expect(on!.nextRunAt).toBeGreaterThan(Date.now());
+  });
+
+  test("upsert rewrites a moved script path without touching timing", async () => {
+    const created = await upsertDeclaredSchedule(
+      SOURCE_KEY,
+      makeDefinition({
+        mode: "script",
+        message: "",
+        script: "sh '/workspace-a/plugins/example/schedules/daily/index.sh'",
+      }),
+    );
+
+    // Same definition hash: relocation moves the absolute entrypoint path
+    // while the schedules/-relative content is unchanged.
+    const updated = await upsertDeclaredSchedule(
+      SOURCE_KEY,
+      makeDefinition({
+        mode: "script",
+        message: "",
+        script: "sh '/workspace-b/plugins/example/schedules/daily/index.sh'",
+      }),
+    );
+
+    expect(updated.script).toBe(
+      "sh '/workspace-b/plugins/example/schedules/daily/index.sh'",
+    );
+    expect(updated.definitionHash).toBe("hash-1");
+    expect(updated.nextRunAt).toBe(created.nextRunAt);
+  });
+
+  test("cancelSchedule refuses sourced rows", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+    const before = rawJob(created.id);
+
+    await expect(cancelSchedule(created.id)).rejects.toThrow(UserError);
+    await expect(cancelSchedule(created.id)).rejects.toThrow(
+      /managed by a plugin/,
+    );
+    expect(rawJob(created.id)).toEqual(before);
+  });
+
+  test("enabling a row whose declaration is gone records the override without re-arming", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+    await setUserEnabled(created.id, false);
+    rmSync(examplePluginDir(), { recursive: true, force: true });
+
+    const result = await setUserEnabled(created.id, true);
+
+    expect(result!.userEnabled).toBe(true);
+    expect(result!.enabled).toBe(false);
+  });
+
+  test("a flat markdown file does not satisfy the enable probe", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+    await setUserEnabled(created.id, false);
+    const schedulesDir = join(examplePluginDir(), "schedules");
+    rmSync(join(schedulesDir, "daily"), { recursive: true, force: true });
+    writeFileSync(join(schedulesDir, "daily.md"), "declaration");
+
+    const result = await setUserEnabled(created.id, true);
+
+    expect(result!.userEnabled).toBe(true);
+    expect(result!.enabled).toBe(false);
+  });
+
+  test("enabling a schedule of a disabled plugin records the override without re-arming", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+    await setUserEnabled(created.id, false);
+    // The declaration file is still on disk; the `.disabled` sentinel alone
+    // must keep the enable probe from re-arming the row before the next
+    // reconcile pass.
+    writeFileSync(join(examplePluginDir(), ".disabled"), "");
+
+    const result = await setUserEnabled(created.id, true);
+
+    expect(result!.userEnabled).toBe(true);
+    expect(result!.enabled).toBe(false);
+  });
+
+  test("enabling a schedule whose plugin manifest is broken records the override without re-arming", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+    await setUserEnabled(created.id, false);
+    // The reconciler disarms the schedules of a plugin the loader refuses to
+    // bring up, so a toggle must not re-arm one before the next sweep.
+    writeFileSync(join(examplePluginDir(), "package.json"), "{not json");
+
+    const result = await setUserEnabled(created.id, true);
+
+    expect(result!.userEnabled).toBe(true);
+    expect(result!.enabled).toBe(false);
+  });
+
+  test("updateSchedule refuses sourced rows", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+    const before = rawJob(created.id);
+
+    await expect(
+      updateSchedule(created.id, { name: "renamed" }),
+    ).rejects.toThrow(UserError);
+    await expect(
+      updateSchedule(created.id, { name: "renamed" }),
+    ).rejects.toThrow(/managed by a plugin/);
+    expect(rawJob(created.id)).toEqual(before);
+  });
+
+  test("deleteSchedule refuses sourced rows and keeps runs", async () => {
+    const created = await upsertDeclaredSchedule(SOURCE_KEY, makeDefinition());
+    const runId = await createScheduleRun(created.id, "conv-123");
+    await completeScheduleRun(runId, { status: "ok" });
+
+    await expect(deleteSchedule(created.id)).rejects.toThrow(UserError);
+    await expect(deleteSchedule(created.id)).rejects.toThrow(
+      /managed by a plugin/,
+    );
+
+    expect(getSchedule(created.id)).not.toBeNull();
+    const runs = getRawDb()
+      .query("SELECT COUNT(*) AS n FROM cron_runs WHERE job_id = ?")
+      .get(created.id) as { n: number };
+    expect(runs.n).toBe(1);
+  });
+
+  test("update and delete on imperative rows are unchanged", async () => {
+    const imperative = await createSchedule({
+      name: "Mine",
+      cronExpression: "0 8 * * *",
+      message: "hello",
+      syntax: "cron",
+    });
+
+    const renamed = await updateSchedule(imperative.id, { name: "Renamed" });
+    expect(renamed!.name).toBe("Renamed");
+
+    expect(await deleteSchedule(imperative.id)).toBe(true);
+    expect(getSchedule(imperative.id)).toBeNull();
+  });
+});
+
+// ── Inference-profile pinning ─────────────────────────────────────────────
+
+/**
+ * Every assertion below compares against the live resolution rather than a
+ * literal key, so the tests describe the invariant (a schedule is pinned to
+ * whatever the default resolves to at write time) instead of freezing this
+ * workspace's shipped profile catalog.
+ */
+describe("inference-profile pinning", () => {
+  beforeEach(() => {
+    getDb().run("DELETE FROM cron_runs");
+    getDb().run("DELETE FROM cron_jobs");
+    getDb().run("DELETE FROM conversations");
+  });
+
+  test("creation with no profile pins the resolved default", async () => {
+    const expected = resolveDefaultScheduleInferenceProfile();
+    expect(expected).not.toBeNull();
+
+    const job = await createSchedule({
+      name: "Unpinned",
+      message: "hi",
+      cronExpression: "0 9 * * *",
+    });
+
+    expect(job.inferenceProfile).toBe(expected!);
+    expect(getSchedule(job.id)!.inferenceProfile).toBe(expected!);
+  });
+
+  test("creation with an explicit profile keeps it", async () => {
+    expect(resolveDefaultScheduleInferenceProfile()).not.toBe("cost-optimized");
+
+    const job = await createSchedule({
+      name: "Pinned",
+      message: "hi",
+      cronExpression: "0 9 * * *",
+      inferenceProfile: "cost-optimized",
+    });
+
+    expect(job.inferenceProfile).toBe("cost-optimized");
+  });
+
+  test("updating to null re-snapshots the default instead of unpinning", async () => {
+    const job = await createSchedule({
+      name: "Repinned",
+      message: "hi",
+      cronExpression: "0 9 * * *",
+      inferenceProfile: "cost-optimized",
+    });
+
+    const updated = await updateSchedule(job.id, { inferenceProfile: null });
+
+    expect(updated!.inferenceProfile).toBe(
+      resolveDefaultScheduleInferenceProfile()!,
+    );
+  });
+
+  test("a defer seeds the source conversation's pinned profile", async () => {
+    const conversation = createConversation({ id: "conv-pinned" });
+    setConversationInferenceProfile(conversation.id, "cost-optimized");
+    expect(resolveDefaultScheduleInferenceProfile()).not.toBe("cost-optimized");
+
+    const job = await createOwnerDeferredWake({
+      conversationId: conversation.id,
+      hint: "check back",
+      fireAt: Date.now() + 60_000,
+    });
+
+    // The wake resumes this conversation and forces the row's pin as the
+    // turn's override, so seeding from the global default would move a pinned
+    // conversation's own follow-up onto a different model.
+    expect(job.inferenceProfile).toBe("cost-optimized");
+  });
+
+  test("a defer does not freeze the source conversation's profile session", async () => {
+    const conversation = createConversation({ id: "conv-session" });
+    setConversationInferenceProfileSession(
+      conversation.id,
+      "cost-optimized",
+      "session-1",
+      Date.now() + 10 * 60_000,
+    );
+
+    const job = await createOwnerDeferredWake({
+      conversationId: conversation.id,
+      hint: "check back",
+      fireAt: Date.now() + 7 * 24 * 60 * 60_000,
+    });
+
+    // A profile session is a deliberately temporary choice. Snapshotting it
+    // into the row would keep billing that model every time the wake fires,
+    // long after the ten-minute session lapsed.
+    expect(job.inferenceProfile).toBe(
+      resolveDefaultScheduleInferenceProfile()!,
+    );
+  });
+
+  test("a defer from an unpinned conversation seeds the default", async () => {
+    const conversation = createConversation({ id: "conv-unpinned" });
+
+    const job = await createOwnerDeferredWake({
+      conversationId: conversation.id,
+      hint: "check back",
+      fireAt: Date.now() + 60_000,
+    });
+
+    expect(job.inferenceProfile).toBe(
+      resolveDefaultScheduleInferenceProfile()!,
+    );
+  });
+
+  test("any wake row seeds its target's pin, not just a defer", async () => {
+    const conversation = createConversation({ id: "conv-wake-target" });
+    setConversationInferenceProfile(conversation.id, "cost-optimized");
+    expect(resolveDefaultScheduleInferenceProfile()).not.toBe("cost-optimized");
+
+    // Seeding is keyed on `mode: "wake"` at the insert chokepoint rather than
+    // on defer provenance: every wake row forces its pin as the woken turn's
+    // override, so a wake minted any other way must not flatten its target's
+    // choice onto the global default either.
+    const job = await createSchedule({
+      name: "Wake pinned conversation",
+      message: "resume",
+      nextRunAt: Date.now() + 60_000,
+      mode: "wake",
+      wakeConversationId: conversation.id,
+    });
+
+    expect(job.inferenceProfile).toBe("cost-optimized");
+  });
+});

package/src/__tests__/schedule-tools.test.ts

@@ -9,6 +9,7 @@ import { createGroup, deleteGroup } from "../persistence/group-crud.js";
 import {
   getSchedule,
   resolveScheduleConversationGroupId,
+  upsertDeclaredSchedule,
 } from "../schedule/schedule-store.js";
 import {
   __clearRegistryForTesting,
@@ -1888,6 +1889,108 @@ describe("schedule_delete tool", () => {
   });
 });
 
+// ── plugin-sourced schedules ────────────────────────────────────────
+
+describe("schedule tools on plugin-sourced schedules", () => {
+  beforeEach(() => {
+    getRawDb().run("DELETE FROM cron_runs");
+    getRawDb().run("DELETE FROM cron_jobs");
+  });
+
+  function createSourcedSchedule() {
+    return upsertDeclaredSchedule("plugin:example/daily", {
+      name: "daily",
+      syntax: "cron",
+      expression: "0 9 * * *",
+      message: "Do the daily thing.",
+      mode: "execute",
+      enabled: true,
+      definitionHash: "hash-1",
+    });
+  }
+
+  test("schedule_update toggles enabled via the user_enabled override", async () => {
+    const job = await createSourcedSchedule();
+
+    const result = await executeScheduleUpdate(
+      { job_id: job.id, enabled: false },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Schedule updated successfully");
+    expect(result.content).toContain("Enabled: false");
+
+    const row = getRawDb()
+      .query("SELECT enabled, user_enabled FROM cron_jobs WHERE id = ?")
+      .get(job.id) as { enabled: number; user_enabled: number };
+    expect(row.enabled).toBe(0);
+    expect(row.user_enabled).toBe(0);
+  });
+
+  test("schedule_update refuses definition fields with a message naming the enabled toggle", async () => {
+    const job = await createSourcedSchedule();
+
+    const result = await executeScheduleUpdate(
+      { job_id: job.id, name: "renamed" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("managed by a plugin");
+    expect(result.content).toContain("only enabled can be changed");
+    expect(getSchedule(job.id)?.name).toBe("daily");
+  });
+
+  test("schedule_update refuses enabled mixed with definition fields", async () => {
+    const job = await createSourcedSchedule();
+
+    const result = await executeScheduleUpdate(
+      { job_id: job.id, enabled: false, message: "rewritten" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("managed by a plugin");
+    expect(getSchedule(job.id)?.enabled).toBe(true);
+  });
+
+  test("schedule_delete surfaces the store refusal as a normal tool error", async () => {
+    const job = await createSourcedSchedule();
+
+    const result = await executeScheduleDelete({ job_id: job.id }, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("managed by a plugin");
+    expect(getSchedule(job.id)).not.toBeNull();
+  });
+
+  test("schedule_list marks plugin-managed rows in list and detail modes", async () => {
+    const job = await createSourcedSchedule();
+
+    const list = await executeScheduleList({}, ctx);
+    expect(list.isError).toBe(false);
+    expect(list.content).toContain("(managed by plugin example)");
+
+    const detail = await executeScheduleList({ job_id: job.id }, ctx);
+    expect(detail.isError).toBe(false);
+    expect(detail.content).toContain("Managed by plugin: example");
+    expect(detail.content).toContain("only enabled can be changed");
+  });
+
+  test("schedule_list carries no plugin marker on imperative rows", async () => {
+    const created = await executeScheduleCreate(
+      { name: "imperative", expression: "0 9 * * *", message: "Do the thing." },
+      ctx,
+    );
+    expect(created.isError).toBe(false);
+
+    const list = await executeScheduleList({}, ctx);
+    expect(list.isError).toBe(false);
+    expect(list.content).not.toContain("managed by plugin");
+  });
+});
+
 // ── model-input schema validation (LUM-2853) ────────────────────────
 
 describe("schedule tools — model-input schema validation", () => {