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

package/src/cli/lib/install-from-github.ts

@@ -154,6 +154,20 @@ export interface InstallPluginOptions {
   readonly trustedSource?: PluginFetchSource;
 }
 
+/**
+ * Consent gate invoked after the plugin tree is fully staged and before it is
+ * finalized (dependencies installed, provenance recorded, swapped live). The
+ * caller inspects the staged tree to see what the plugin declares (e.g.
+ * schedules) and asks the user. Returning `false` aborts the install: the
+ * staging directory is removed, nothing is swapped, and
+ * {@link PluginInstallDeclinedError} is thrown.
+ */
+export type ConfirmStagedInstall = (staged: {
+  readonly name: string;
+  /** Absolute path of the fully materialized staging directory. */
+  readonly stagingDir: string;
+}) => Promise<boolean>;
+
 /** Dependencies injected by the caller. */
 export interface InstallPluginDeps {
   /** HTTP client. Production callers pass `globalThis.fetch.bind(globalThis)`. */
@@ -168,6 +182,8 @@ export interface InstallPluginDeps {
   readonly runInstallDeps?: DependencyInstaller;
   /** Forwarded to {@link finalizeStagedInstall}; see {@link FinalizeStagedInstallParams.beforeSwap}. */
   readonly beforeSwap?: () => Promise<void>;
+  /** Consent gate between staging and finalize; see {@link ConfirmStagedInstall}. */
+  readonly confirmStaged?: ConfirmStagedInstall;
 }
 
 /** Successful install result. */
@@ -214,6 +230,19 @@ export class PluginPostinstallError extends Error {
   }
 }
 
+/**
+ * The caller's {@link ConfirmStagedInstall} gate declined the staged install.
+ * Nothing was installed and the staging directory was removed. The caller that
+ * supplied the gate owns the user-facing messaging, so this error signals the
+ * outcome rather than something to report as a failure.
+ */
+export class PluginInstallDeclinedError extends Error {
+  constructor(pluginName: string) {
+    super(`Install of "${pluginName}" was declined.`);
+    this.name = "PluginInstallDeclinedError";
+  }
+}
+
 /** A plugin with the same name is already installed and `--force` was not passed. */
 export class PluginAlreadyInstalledError extends Error {
   constructor(
@@ -503,6 +532,8 @@ export async function installPlugin(
     throw new PluginNotFoundError(name, ref, sourceLabel(effectiveSource));
   }
 
+  await confirmStagedOrAbort(name, stagingDir, deps.confirmStaged);
+
   await finalizeStagedInstall(stagingDir, {
     name,
     source: effectiveSource,
@@ -517,6 +548,36 @@ export async function installPlugin(
   return { name, target, fileCount, ref, commit, committedAt };
 }
 
+/**
+ * Run the caller's {@link ConfirmStagedInstall} gate over the staged tree. A
+ * decline (or a gate that throws) removes the staging directory so no partial
+ * install is left behind; a decline then surfaces as
+ * {@link PluginInstallDeclinedError}. A no-op when no gate was supplied.
+ *
+ * Shared by {@link installPlugin} and the platform-endpoint install so both
+ * abort a declined install the same way.
+ */
+export async function confirmStagedOrAbort(
+  name: string,
+  stagingDir: string,
+  confirmStaged: ConfirmStagedInstall | undefined,
+): Promise<void> {
+  if (!confirmStaged) {
+    return;
+  }
+  let confirmed = false;
+  try {
+    confirmed = await confirmStaged({ name, stagingDir });
+  } finally {
+    if (!confirmed) {
+      rmSync(stagingDir, { recursive: true, force: true });
+    }
+  }
+  if (!confirmed) {
+    throw new PluginInstallDeclinedError(name);
+  }
+}
+
 /** Inputs for {@link finalizeStagedInstall}. */
 export interface FinalizeStagedInstallParams {
   readonly name: string;

package/src/cli/lib/install-from-platform.ts

@@ -33,6 +33,8 @@ import { getWorkspacePluginsDir } from "../../util/platform.js";
 import { APP_VERSION } from "../../version.js";
 import type { FetchLike } from "./fetch-like.js";
 import {
+  type ConfirmStagedInstall,
+  confirmStagedOrAbort,
   finalizeStagedInstall,
   type InstallPluginResult,
   PluginAlreadyInstalledError,
@@ -123,6 +125,8 @@ export interface InstallFromPlatformDeps {
   readonly maxAttempts?: number;
   /** Sleep between retries. Injected so tests don't wait real time. */
   readonly sleep?: (ms: number) => Promise<void>;
+  /** Consent gate between staging and finalize; see {@link ConfirmStagedInstall}. */
+  readonly confirmStaged?: ConfirmStagedInstall;
 }
 
 /** Total attempts (initial + retries) for a transient upstream status. */
@@ -194,6 +198,8 @@ export async function installPluginFromPlatform(
     throw new PluginNotFoundError(name, meta.ref ?? "", meta.repo ?? name);
   }
 
+  await confirmStagedOrAbort(name, stagingDir, deps.confirmStaged);
+
   // Record provenance for future update/version UX. The endpoint re-roots the
   // tarball to the plugin root, so the recorded ref is the pinned commit and
   // the ETag documents exactly which bytes were verified.
@@ -223,7 +229,7 @@ export async function installPluginFromPlatform(
  */
 export async function installPluginViaPlatform(
   opts: { name: string; force?: boolean; conversationId?: string },
-  deps: { fetch: FetchLike },
+  deps: { fetch: FetchLike; confirmStaged?: ConfirmStagedInstall },
 ): Promise<InstallPluginResult> {
   const platformBaseUrl = getPlatformBaseUrl();
   const apiKey = await resolveAssistantApiKey();
@@ -237,7 +243,12 @@ export async function installPluginViaPlatform(
       ...(opts.conversationId ? { conversationId: opts.conversationId } : {}),
       assistantVersion: APP_VERSION,
     },
-    { fetch: deps.fetch, platformBaseUrl, ...(apiKey ? { apiKey } : {}) },
+    {
+      fetch: deps.fetch,
+      platformBaseUrl,
+      ...(apiKey ? { apiKey } : {}),
+      ...(deps.confirmStaged ? { confirmStaged: deps.confirmStaged } : {}),
+    },
   );
 }
 

package/src/cli/lib/plugin-surfaces.ts

@@ -10,17 +10,29 @@
  *                                (see the external plugin loader's tool walk).
  * - `skills/<id>/SKILL.md`     → a skill owned by the plugin (see the skills
  *                                catalog's `discoverPluginResidentSkills`).
+ * - `schedules/<name>/`        → a declared schedule (see the daemon's plugin
+ *                                schedule declaration parser).
  *
  * This module re-derives those same sets so `plugins inspect` can report exactly
  * what a plugin contributes. Detection is intentionally a self-contained walk of
- * the install tree — `cli/lib` does not reach into the daemon-internal loader or
- * skills catalog — but it mirrors their conventions so inspect agrees with what
- * the runtime actually loads.
+ * the install tree (`cli/lib` does not reach into the daemon-internal loader,
+ * skills catalog, or schedule parser), but it mirrors their conventions so
+ * inspect agrees with what the runtime actually loads.
  */
 
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 
+/** A schedule the plugin declares under `schedules/`. */
+export interface PluginScheduleSurface {
+  /** Schedule name: the declaration directory's name. */
+  readonly name: string;
+  /** Raw schedule `expression` string from the declaration's config. */
+  readonly cadence: string;
+  /** `execute` for a markdown prompt entrypoint, `script` for `index.sh`. */
+  readonly mode: "execute" | "script";
+}
+
 /** The surfaces an installed plugin contributes, each sorted and de-duplicated. */
 export interface PluginSurfaces {
   /** Skill ids shipped at `skills/<id>/SKILL.md`. */
@@ -36,6 +48,18 @@ export interface PluginSurfaces {
    * importing and executing untrusted plugin code, which inspection avoids.
    */
   readonly tools: readonly string[];
+  /**
+   * Schedules declared under `schedules/`, each a `<name>/` directory with a
+   * `config.json` plus exactly one `index.md` (`execute`) or `index.sh`
+   * (`script`) entrypoint. This is a display surface, not the arming path:
+   * a file directly under `schedules/` and structurally malformed directories
+   * (a bad entrypoint set, an empty prompt body, frontmatter in `index.md`, an
+   * unreadable config, a missing `expression`) are skipped rather than reported
+   * as errors. Detection stays permissive beyond structure: `expression`
+   * validity is not checked CLI-side, so a declaration whose expression the
+   * daemon rejects is still listed here.
+   */
+  readonly schedules: readonly PluginScheduleSurface[];
 }
 
 /**
@@ -97,6 +121,101 @@ function listSkillIds(skillsDir: string): string[] {
   return ids.sort();
 }
 
+/** Matches a `---` delimited YAML frontmatter block at the start of a file. */
+const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+
+/** Read the raw `expression` string from a parsed schedule config, or `null`. */
+function readConfigExpression(config: unknown): string | null {
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    return null;
+  }
+  const expression = (config as Record<string, unknown>).expression;
+  return typeof expression === "string" && expression.trim() !== ""
+    ? expression
+    : null;
+}
+
+/**
+ * Read a `<name>/` directory declaration: `config.json` supplies the cadence
+ * and the single `index.md`/`index.sh` entrypoint decides the mode. `null` for
+ * anything the loader would refuse (zero or multiple `index.*` entries, an
+ * unsupported entrypoint, an `index.md` carrying frontmatter or an empty
+ * prompt body, an unreadable config, a missing expression).
+ */
+function readDirectorySchedule(
+  dirPath: string,
+): { cadence: string; mode: PluginScheduleSurface["mode"] } | null {
+  let children;
+  try {
+    children = readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const entrypoints = children
+    .filter((c) => c.isFile() && c.name.startsWith("index."))
+    .map((c) => c.name);
+  if (entrypoints.length !== 1) {
+    return null;
+  }
+  const entrypoint = entrypoints[0]!;
+  if (entrypoint !== "index.md" && entrypoint !== "index.sh") {
+    return null;
+  }
+  if (entrypoint === "index.md") {
+    let body: string;
+    try {
+      body = readFileSync(join(dirPath, "index.md"), "utf8");
+    } catch {
+      return null;
+    }
+    // Directory-form config belongs in config.json, so the loader refuses an
+    // index.md with frontmatter; it also refuses an empty prompt body.
+    if (FRONTMATTER_REGEX.test(body) || !body.trim()) {
+      return null;
+    }
+  }
+  let config: unknown;
+  try {
+    config = JSON.parse(readFileSync(join(dirPath, "config.json"), "utf8"));
+  } catch {
+    return null;
+  }
+  const cadence = readConfigExpression(config);
+  if (cadence === null) {
+    return null;
+  }
+  return { cadence, mode: entrypoint === "index.md" ? "execute" : "script" };
+}
+
+/**
+ * List the schedules a plugin declares under `schedules/`, mirroring the
+ * declaration parser's directory-only form. A file directly under
+ * `schedules/` is not a declaration, so it is skipped. Returns schedules
+ * sorted by name; a missing directory yields `[]`.
+ */
+function listSchedules(schedulesDir: string): PluginScheduleSurface[] {
+  let entries;
+  try {
+    entries = readdirSync(schedulesDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const schedules: PluginScheduleSurface[] = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || !entry.isDirectory()) {
+      continue;
+    }
+    const parsed = readDirectorySchedule(join(schedulesDir, entry.name));
+    if (parsed) {
+      schedules.push({ name: entry.name, ...parsed });
+    }
+  }
+  return schedules.sort((a, b) =>
+    a.name < b.name ? -1 : a.name > b.name ? 1 : 0,
+  );
+}
+
 /**
  * Detect the {@link PluginSurfaces} an installed plugin contributes by walking
  * its install tree at `pluginDir`. Surface types with no contributions come
@@ -110,5 +229,6 @@ export function detectPluginSurfaces(pluginDir: string): PluginSurfaces {
     skills: listSkillIds(join(pluginDir, "skills")),
     hooks: listModuleBasenames(join(pluginDir, "hooks")),
     tools: [...new Set(toolNames)].sort(),
+    schedules: listSchedules(join(pluginDir, "schedules")),
   };
 }

package/src/cli/lib/upgrade-plugin.ts

@@ -17,6 +17,11 @@
  * verbatim, with no curated adapter overlay, exactly as the original untrusted
  * install was (see {@link directUpgrade}).
  *
+ * Because that target is a mutable ref, taking it means running whatever
+ * upstream pushed since, which is a choice only a human should make. A caller
+ * with nobody in the loop passes `marketplaceOnly` to rule it out: the direct
+ * path then throws {@link PluginNotCuratedError} instead of advancing.
+ *
  * This is deliberately a distinct operation from install: `install` is
  * first-time materialization (and errors on an existing install unless
  * `--force` is passed), whereas `upgrade` moves an existing install forward.
@@ -54,6 +59,8 @@ import {
   type PluginLocalInfo,
 } from "./inspect-plugin.js";
 import {
+  type ConfirmStagedInstall,
+  confirmStagedOrAbort,
   finalizeStagedInstall,
   type GitRunner,
   installPlugin,
@@ -112,6 +119,20 @@ export interface UpgradePluginOptions {
    * {@link DEFAULT_PLUGIN_UPGRADE_STRATEGY}.
    */
   readonly strategy?: PluginUpgradeStrategy;
+  /**
+   * Refuse to advance an install the marketplace does not claim, instead of
+   * falling back to {@link directUpgrade}.
+   *
+   * A direct install's upgrade target is a mutable upstream ref, so taking it
+   * means fetching and executing whatever was pushed since. Callers with
+   * nobody in the loop (the unattended auto-update sweep) set this so that
+   * outcome is impossible for them, and it is enforced here rather than by the
+   * caller's own pre-check: the catalog is fetched again inside this call, so
+   * an entry that disappears in between would otherwise silently reroute a
+   * curated upgrade into a direct one. Defaults to false, which is what an
+   * interactive `assistant plugins upgrade` wants.
+   */
+  readonly marketplaceOnly?: boolean;
 }
 
 /** Dependencies injected by the caller. */
@@ -138,6 +159,14 @@ export interface UpgradePluginDeps {
    * for dry runs or no-op upgrades (they never reach the swap).
    */
   readonly beforeSwap?: () => Promise<void>;
+  /**
+   * Consent gate between staging and finalize, identical to the install
+   * path's ({@link ConfirmStagedInstall}): the caller inspects the staged
+   * upgraded tree (e.g. its declared schedules) and may abort before
+   * anything replaces the live install. Applies to overwrite and merge
+   * upgrades alike; dry runs and no-ops never stage, so it is not invoked.
+   */
+  readonly confirmStaged?: ConfirmStagedInstall;
 }
 
 /** Result of an upgrade attempt. */
@@ -198,6 +227,23 @@ export class PluginNotUpgradableError extends Error {
   }
 }
 
+/**
+ * A `marketplaceOnly` upgrade was requested for an install the marketplace does
+ * not claim, so the only revision available is a mutable upstream ref the
+ * caller refuses to take.
+ *
+ * Distinct from {@link PluginNotUpgradableError}: the install *can* be
+ * upgraded, just not without a human choosing to accept unreviewed code.
+ */
+export class PluginNotCuratedError extends Error {
+  constructor(readonly pluginName: string) {
+    super(
+      `Plugin "${pluginName}" cannot be upgraded automatically: it has no marketplace entry, so its only upgrade target is a mutable upstream ref. Run 'assistant plugins upgrade ${pluginName}' to move it deliberately.`,
+    );
+    this.name = "PluginNotCuratedError";
+  }
+}
+
 /**
  * A merge strategy (`ours`/`theirs`) was requested but the install-time
  * baseline needed for a three-way merge cannot be reconstructed.
@@ -234,6 +280,8 @@ function pluginTarget(name: string, deps: UpgradePluginDeps): string {
  * Throws {@link PluginNotInstalledError} when no copy is installed,
  * {@link PluginNotUpgradableError} when the install is neither in the
  * marketplace nor carries a recorded GitHub source to advance,
+ * {@link PluginNotCuratedError} when `marketplaceOnly` was requested for an
+ * install the marketplace does not claim,
  * {@link PluginMergeBaselineError} when a merge strategy is requested but the
  * install-time baseline cannot be reconstructed,
  * {@link PluginSourceUnavailableError} when the marketplace catalog or the
@@ -292,6 +340,10 @@ export async function upgradePlugin(
           "it has no marketplace entry and no installed copy to upgrade",
         );
       }
+      if (opts.marketplaceOnly) {
+        // The caller only accepts a curated pin, and this install has none.
+        throw new PluginNotCuratedError(name);
+      }
       return directUpgrade({ name, local, dryRun, strategy }, deps);
     }
     case "remote-unavailable":
@@ -401,6 +453,7 @@ export async function upgradePlugin(
       runPostinstall: deps.runPostinstall,
       runInstallDeps: deps.runInstallDeps,
       beforeSwap: deps.beforeSwap,
+      confirmStaged: deps.confirmStaged,
     },
   );
 
@@ -591,6 +644,7 @@ async function directUpgrade(
       runPostinstall: deps.runPostinstall,
       runInstallDeps: deps.runInstallDeps,
       beforeSwap: deps.beforeSwap,
+      confirmStaged: deps.confirmStaged,
     },
   );
 
@@ -747,6 +801,12 @@ async function mergeUpgrade(
       conflictLabels,
     });
 
+    // Same staging-to-finalize consent boundary as `installPlugin`: the
+    // caller sees the fully merged tree before it replaces the live install.
+    // A decline removes the staging dir and throws; the outer catch's rmSync
+    // is then a no-op.
+    await confirmStagedOrAbort(name, stagingDir, deps.confirmStaged);
+
     const toCommit = theirs.commit ?? ctx.toCommit;
     const toTimestamp = theirs.committedAt ?? ctx.toTimestamp;
     await finalizeStagedInstall(stagingDir, {

package/src/cli.ts

@@ -513,7 +513,7 @@ export async function startCli(): Promise<void> {
     if (content === "/conversations") {
       pendingSessionPick = true;
       try {
-        const rows = listConversations(20);
+        const rows = listConversations({ limit: 20 });
         const conversations = rows.map((r) => ({
           id: r.id,
           title: r.title || "Untitled",

package/src/config/__tests__/default-profile-catalog.test.ts

@@ -22,6 +22,7 @@ import {
 import {
   type DefaultProviderConfig,
   type LLMCallSite,
+  LLMCallSiteEnum,
   LLMSchema,
   type ProfileEntry,
 } from "../schemas/llm.js";
@@ -245,7 +246,10 @@ describe("resolver integration", () => {
       },
     });
     const body = CODE_DEFAULT_PROFILE_ENTRIES["latency-optimized"]!;
-    for (const callSite of ["voiceFrontDoor", "voiceFrontDecision"] as const) {
+    for (const callSite of [
+      "voiceFrontDoor",
+      "voiceProgressNarration",
+    ] as const) {
       const resolved = resolveCallSiteConfig(callSite, llm);
       expect(resolved.model).toBe(body.model as string);
       expect(resolved.model).not.toBe("claude-opus-4-6");
@@ -265,6 +269,12 @@ describe("resolver integration", () => {
 });
 
 describe("schema validation", () => {
+  test("voiceFrontDoor is the only front callsite", () => {
+    expect(
+      LLMCallSiteEnum.options.filter((callSite) => callSite.includes("Front")),
+    ).toEqual(["voiceFrontDoor"]);
+  });
+
   test("always-available default names are valid references; os-beta only when materialized", () => {
     expect(() => LLMSchema.parse({ activeProfile: "balanced" })).not.toThrow();
     expect(() =>

package/src/config/__tests__/deployment-context-defaults.test.ts

@@ -1,6 +1,7 @@
 import {
   existsSync,
   mkdirSync,
+  readdirSync,
   readFileSync,
   rmSync,
   writeFileSync,
@@ -267,4 +268,76 @@ describe("deployment-context embedding-provider default (via loadConfig)", () =>
     >;
     expect(v3Raw.live).toBe(true);
   });
+
+  describe("quarantine-reseed carries memory.v3.live forward", () => {
+    function removeQuarantineFiles(): void {
+      for (const name of readdirSync(WORKSPACE_DIR)) {
+        if (name.startsWith("config.json.corrupt-")) {
+          rmSync(join(WORKSPACE_DIR, name), { force: true });
+        }
+      }
+    }
+
+    function readV3Raw(): Record<string, unknown> {
+      const raw = readConfig();
+      return ((raw.memory as Record<string, unknown>).v3 ?? {}) as Record<
+        string,
+        unknown
+      >;
+    }
+
+    afterEach(() => {
+      removeQuarantineFiles();
+    });
+
+    test("a corrupt live-v3 config is quarantined and the reseed keeps live=true", () => {
+      // Truncated mid-write JSON from a memory-v3 assistant: unparseable,
+      // but the live flag survives in the raw text.
+      writeFileSync(
+        CONFIG_PATH,
+        `{\n  "memory": {\n    "v3": {\n      "live": true\n    }\n  },\n  "llm": {\n    "activeProf`,
+      );
+
+      const config = loadConfig();
+
+      // The corrupt file was quarantined and the reseeded config carries the
+      // tier forward, both in-memory (this boot runs v3) and on disk
+      // (migration 105 is checkpointed on existing workspaces and never
+      // re-runs, so the persisted value is the only durable record).
+      expect(config.memory.v3.live).toBe(true);
+      expect(readV3Raw()).toEqual({ live: true });
+    });
+
+    test("a corrupt config without live=true reseeds with the leaf absent", () => {
+      writeFileSync(
+        CONFIG_PATH,
+        `{\n  "memory": {\n    "v3": {\n      "live": false\n    }\n  },\n  "llm": {\n    "activeProf`,
+      );
+
+      const config = loadConfig();
+
+      // Never carry `false` forward: an absent leaf is the only way to keep
+      // "no decision recorded" representable for migration 105.
+      expect(config.memory.v3.live).toBe(false);
+      expect(readV3Raw()).toEqual({});
+    });
+
+    test("a deleted config with an earlier live-v3 quarantine still carries live=true", () => {
+      if (existsSync(CONFIG_PATH)) {
+        rmSync(CONFIG_PATH, { force: true });
+      }
+      writeFileSync(
+        join(
+          WORKSPACE_DIR,
+          "config.json.corrupt-2026-08-01T10-00-00.000Z.json",
+        ),
+        JSON.stringify({ memory: { v3: { live: true } } }, null, 2),
+      );
+
+      const config = loadConfig();
+
+      expect(config.memory.v3.live).toBe(true);
+      expect(readV3Raw()).toEqual({ live: true });
+    });
+  });
 });

package/src/config/__tests__/memory-retrospective-schema.test.ts

@@ -0,0 +1,40 @@
+/**
+ * Guards over the `memory.retrospective` switches that decide whether the
+ * retrospective pass runs at all, and how its fork is materialized.
+ *
+ * The defaults are the contract: a workspace that says nothing must behave
+ * exactly as it did before the fields existed: retrospectives on, forks
+ * cloned.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { MemoryRetrospectiveConfigSchema } from "../schemas/memory-retrospective.js";
+
+describe("memory.retrospective config schema", () => {
+  test("an empty block leaves retrospectives on and forks cloning", () => {
+    const parsed = MemoryRetrospectiveConfigSchema.parse({});
+    expect(parsed.enabled).toBe(true);
+    expect(parsed.forkStrategy).toBe("cloning");
+  });
+
+  test("enabled is a boolean-only kill switch", () => {
+    expect(
+      MemoryRetrospectiveConfigSchema.parse({ enabled: false }).enabled,
+    ).toBe(false);
+    expect(
+      MemoryRetrospectiveConfigSchema.safeParse({ enabled: "false" }).success,
+    ).toBe(false);
+  });
+
+  test("forkStrategy accepts only cloning and reference", () => {
+    expect(
+      MemoryRetrospectiveConfigSchema.parse({ forkStrategy: "reference" })
+        .forkStrategy,
+    ).toBe("reference");
+    expect(
+      MemoryRetrospectiveConfigSchema.safeParse({ forkStrategy: "referential" })
+        .success,
+    ).toBe(false);
+  });
+});

package/src/config/__tests__/plugin-updates-schema.test.ts

@@ -0,0 +1,43 @@
+/**
+ * Guards over the `pluginUpdates` config block — the opt-in that decides
+ * whether installed plugins move on their own.
+ *
+ * The defaults are the contract: a workspace that says nothing must behave
+ * exactly as it did before the block existed (manual, nothing upgrades), and
+ * an opted-in workspace must land on the `theirs` merge strategy.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { PluginUpdatesConfigSchema } from "../schemas/plugin-updates.js";
+
+describe("pluginUpdates config schema", () => {
+  test("defaults are manual / theirs / hourly", () => {
+    expect(PluginUpdatesConfigSchema.parse({})).toEqual({
+      mode: "manual",
+      strategy: "theirs",
+      checkIntervalMs: 3_600_000,
+    });
+  });
+
+  test("mode accepts only manual and auto", () => {
+    expect(PluginUpdatesConfigSchema.parse({ mode: "auto" }).mode).toBe("auto");
+    expect(
+      PluginUpdatesConfigSchema.safeParse({ mode: "sometimes" }).success,
+    ).toBe(false);
+  });
+
+  test("the unattended-hostile `assistant` strategy is not selectable", () => {
+    // It resolves conflicts by writing git conflict markers into the plugin's
+    // files, which unattended would leave broken code on disk.
+    expect(
+      PluginUpdatesConfigSchema.safeParse({ strategy: "assistant" }).success,
+    ).toBe(false);
+  });
+
+  test("sub-5-minute sweep intervals are rejected", () => {
+    expect(
+      PluginUpdatesConfigSchema.safeParse({ checkIntervalMs: 1_000 }).success,
+    ).toBe(false);
+  });
+});