@vellumai/assistant 0.11.4-staging.2 → 0.11.4-staging.4

package/src/runtime/routes/playground/inject-failures.ts

@@ -72,7 +72,7 @@ export const ROUTES: RouteDefinition[] = [
         if (circuitOpenForMs === 0) {
           if (circuit.compactionCircuitOpenUntil !== null) {
             circuit.compactionCircuitOpenUntil = null;
-            conversation.sendToClient({
+            conversation.emit({
               type: "compaction_circuit_closed",
               conversationId: conversation.conversationId,
             });
@@ -80,7 +80,7 @@ export const ROUTES: RouteDefinition[] = [
         } else {
           const openUntil = Date.now() + circuitOpenForMs;
           circuit.compactionCircuitOpenUntil = openUntil;
-          conversation.sendToClient({
+          conversation.emit({
             type: "compaction_circuit_open",
             conversationId: conversation.conversationId,
             reason: "3_consecutive_failures",

package/src/runtime/routes/playground/reset-circuit.ts

@@ -52,7 +52,7 @@ export const ROUTES: RouteDefinition[] = [
       circuit.consecutiveCompactionFailures = 0;
       if (circuit.compactionCircuitOpenUntil !== null) {
         circuit.compactionCircuitOpenUntil = null;
-        conversation.sendToClient({
+        conversation.emit({
           type: "compaction_circuit_closed",
           conversationId: conversation.conversationId,
         });

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

@@ -5,6 +5,9 @@
  * the shared ROUTES array.
  */
 
+import { statSync } from "node:fs";
+import { join } from "node:path";
+
 import { z } from "zod";
 
 import { getOrCreateConversation } from "../../daemon/conversation-store.js";
@@ -15,9 +18,10 @@ import {
   getUsageCostForRun,
   listRunConversationIds,
 } from "../../persistence/llm-usage-store.js";
+import { isPluginDisabled } from "../../plugins/disabled-state.js";
 import { isDeferSchedule } from "../../schedule/defer-provenance.js";
 import { validateScheduleInferenceProfile } from "../../schedule/inference-profile.js";
-import { declarationExistsOnDisk } from "../../schedule/plugin-schedule-declarations.js";
+import { pluginScheduleSourceAvailable } from "../../schedule/plugin-schedule-availability.js";
 import { isPluginSchedulesEnabled } from "../../schedule/plugin-schedules-gate.js";
 import {
   describeRRuleExpression,
@@ -38,6 +42,7 @@ import {
   getLastScheduleConversationId,
   getSchedule,
   getScheduleRuns,
+  isEngineLatched,
   listSchedules,
   resolveScheduleConversationGroupId,
   type ScheduleJob,
@@ -49,6 +54,7 @@ import { buildWakeScheduleOptions } from "../../schedule/wake-schedule-options.j
 import { initializeTools } from "../../tools/registry.js";
 import { UserError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
+import { getWorkspacePluginsDir } from "../../util/platform.js";
 import { normalizeCapabilityManifest } from "../../workflows/capabilities.js";
 import { getWorkflowRunManager } from "../../workflows/run-manager.js";
 import { isOwnerCaller } from "../auth/owner-caller.js";
@@ -108,6 +114,76 @@ async function assertWakeMutationAllowed(
 // Response schemas (shared by all schedule routes)
 // ---------------------------------------------------------------------------
 
+const DISARM_REASONS = [
+  "user_disabled",
+  "plugin_removed",
+  "plugin_disabled",
+  "declaration_removed",
+  "declaration_disabled",
+] as const;
+
+type DisarmReason = (typeof DISARM_REASONS)[number];
+
+/**
+ * Why a plugin-sourced schedule sits disarmed, so a client can say so instead
+ * of showing an off row with no explanation.
+ *
+ * Only a sourced row that is off can have one, which also bounds the disk
+ * probes below to those rows. The first matching cause wins, ordered so the
+ * most specific answer comes first: the user's own override outranks anything
+ * the plugin's files say, a plugin that is gone outranks one that is merely
+ * disabled, and a declaration that is gone outranks one that is still there.
+ * `declaration_disabled` is the fallback the plugin's own files account for:
+ * a declared `enabled: false`, a declaration too broken to arm, or a manifest
+ * that no longer parses.
+ *
+ * Two off states never get a reason, because in neither did the plugin's files
+ * turn the schedule off. A row the engine latched (a fired or cancelled
+ * one-shot, a bounded recurrence the claim path exhausted) is a schedule that
+ * finished, not one that is paused. And when the `plugin-schedules` kill switch
+ * is off the reconciler disarms every sourced row regardless of what its
+ * declaration says, so no per-row cause is the true one. Both return null, and
+ * clients show the row like any other schedule that is off.
+ */
+function deriveDisarmReason(
+  job: Pick<
+    ScheduleJob,
+    | "sourceKey"
+    | "enabled"
+    | "userEnabled"
+    | "status"
+    | "nextRunAt"
+    | "lastRunAt"
+  >,
+): DisarmReason | null {
+  if (job.sourceKey === null || job.enabled) {
+    return null;
+  }
+  if (job.userEnabled === false) {
+    return "user_disabled";
+  }
+  if (isEngineLatched(job) || !isPluginSchedulesEnabled()) {
+    return null;
+  }
+  const match = /^plugin:([^/]+)\/(.+)$/.exec(job.sourceKey);
+  if (!match) {
+    return null;
+  }
+  const [, pluginName, scheduleName] = match;
+  const pluginDir = join(getWorkspacePluginsDir(), pluginName!);
+  if (!statSync(pluginDir, { throwIfNoEntry: false })?.isDirectory()) {
+    return "plugin_removed";
+  }
+  if (isPluginDisabled(pluginName!)) {
+    return "plugin_disabled";
+  }
+  const declarationDir = join(pluginDir, "schedules", scheduleName!);
+  if (!statSync(declarationDir, { throwIfNoEntry: false })?.isDirectory()) {
+    return "declaration_removed";
+  }
+  return "declaration_disabled";
+}
+
 const scheduleSchema = z.object({
   id: z.string(),
   name: z.string(),
@@ -150,6 +226,12 @@ const scheduleSchema = z.object({
     .describe(
       "User enable/disable override on a plugin-sourced schedule; null when the declaration's own enabled value applies. Always null for user-created schedules.",
     ),
+  disarmReason: z
+    .enum(DISARM_REASONS)
+    .nullable()
+    .describe(
+      "Why a plugin-sourced schedule is off: the user turned it off, the plugin is gone, the plugin is disabled, the declaration is gone, or the plugin's own files turned it off. Null whenever the schedule is on, and always null for user-created schedules.",
+    ),
   isOneShot: z.boolean(),
   // A deferred wake ("remind me about this tomorrow") is an ordinary schedule
   // row created by the defer path, distinguishable only by `createdBy`, which
@@ -302,6 +384,7 @@ function serializeSchedule(
     workflowName: j.workflowName,
     sourceKey: j.sourceKey,
     userEnabled: j.userEnabled,
+    disarmReason: deriveDisarmReason(j),
     isOneShot: isOneShotForDisplay(j),
     isDeferred: isDeferSchedule(j.createdBy),
   };
@@ -1240,15 +1323,19 @@ async function handleRunScheduleNow(
 
   // A plugin-sourced row runs the plugin's own script or prompt, so run-now is
   // only offered while that plugin is something the runtime would activate.
-  // `declarationExistsOnDisk` is the same probe the enable path uses: it covers
-  // a disabled plugin, an unreadable or invalid manifest, and a declaration
-  // that is simply gone. Turning the feature flag off retires the surface
-  // wholesale and takes the same path. The row can still be armed at this
-  // point, because the reconciler that disarms it runs on its own schedule.
+  // `pluginScheduleSourceAvailable` covers a plugin the daemon never
+  // activated, a disabled plugin, an unreadable or invalid manifest, and a
+  // declaration that is simply gone. Turning the feature flag off retires the
+  // surface wholesale and takes the same path. The row can still be armed at
+  // this point, because the reconciler that disarms it runs on its own
+  // schedule.
+  // Routes are served by the daemon, so the activation half of the probe reads
+  // a live ledger here. Paths that run in worker processes cannot ask that
+  // question and use the on-disk probe alone.
   if (
     schedule.sourceKey !== null &&
     (!isPluginSchedulesEnabled() ||
-      !(await declarationExistsOnDisk(schedule.sourceKey)))
+      !(await pluginScheduleSourceAvailable(schedule.sourceKey)))
   ) {
     throw new BadRequestError(
       "This schedule's plugin is disabled or no longer declares it, so it cannot be run.",

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

@@ -19,7 +19,6 @@ import { basename, dirname, join } from "node:path";
 
 import { z } from "zod";
 
-import { rebindDocumentsToRenamedPath } from "../../documents/document-store.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { publishSoundsConfigUpdated } from "../sync/resource-sync-events.js";
@@ -35,7 +34,6 @@ import {
   isTextMimeType,
   MAX_INLINE_TEXT_SIZE,
   resolveWorkspacePath,
-  toWorkspaceRelativePath,
   writeWorkspaceFile,
 } from "./workspace-utils.js";
 
@@ -505,13 +503,6 @@ function handleWorkspaceRename({ body, headers }: RouteHandlerArgs) {
 
   mkdirSync(dirname(resolvedNew), { recursive: true });
   renameSync(resolvedOld, resolvedNew);
-  // File-backed documents key off the canonical relative path, so they follow
-  // the file to its new name. The request strings are not canonical, hence the
-  // resolved paths.
-  rebindDocumentsToRenamedPath({
-    oldPath: toWorkspaceRelativePath(resolvedOld),
-    newPath: toWorkspaceRelativePath(resolvedNew),
-  });
   publishSoundsConfigUpdatedForPaths(
     [oldPath, newPath],
     headers?.["x-vellum-client-id"]?.trim() || undefined,

package/src/runtime/routes/workspace-utils.ts

@@ -6,7 +6,7 @@ import {
   statSync,
   writeFileSync,
 } from "node:fs";
-import { dirname, relative, resolve, sep } from "node:path";
+import { dirname, resolve, sep } from "node:path";
 
 import { getWorkspaceDir } from "../../util/platform.js";
 import { BadRequestError, ConflictError } from "./errors.js";
@@ -85,22 +85,12 @@ export function resolveWorkspacePath(
   return resolved;
 }
 
-/**
- * Normalise a workspace path to the canonical relative form used as a stable
- * key for the file — forward slashes, no `.`/`..` segments, no leading slash.
- * `absolutePath` must already have passed {@link resolveWorkspacePath}.
- */
-export function toWorkspaceRelativePath(absolutePath: string): string {
-  return relative(getWorkspaceDir(), absolutePath).split(sep).join("/");
-}
-
 /**
  * Write bytes to a workspace-relative path, enforcing the workspace boundary.
  *
  * This is the one write primitive behind every daemon-side workspace file
- * write: the workspace write route and the document store's write-through for
- * file-backed documents both go through it, so the traversal and
- * directory-conflict rules cannot drift apart.
+ * write, so the traversal and directory-conflict rules cannot drift apart
+ * between callers.
  *
  * Returns the number of bytes written. Throws {@link BadRequestError} when the
  * path escapes the workspace and {@link ConflictError} when it names a

package/src/runtime/services/conversation-serializer.ts

@@ -244,13 +244,18 @@ export function serializeConversationSummary(params: {
 
 /**
  * Build a full conversation detail response from a conversation ID.
- * Returns null if the conversation doesn't exist.
+ * Returns null if the conversation doesn't exist, or if it is a legacy
+ * `private` row: every listing hides those by type (see
+ * `standardListingVisibilitySql`) and migration cleanup deletes them, and the
+ * wire type collapses the value to `standard`, so serving one by id would let
+ * a client that only holds a stale id (a persisted last-viewed conversation)
+ * resurrect a row it can never see listed.
  */
 export function buildConversationDetailResponse(
   conversationId: string,
 ): { conversation: ReturnType<typeof serializeConversationSummary> } | null {
   const conversation = getConversation(conversationId);
-  if (!conversation) {
+  if (!conversation || conversation.conversationType === "private") {
     return null;
   }
 

package/src/schedule/__tests__/plugin-schedule-declarations.test.ts

@@ -487,11 +487,39 @@ describe("parsePluginScheduleDeclarations", () => {
       expect(after).not.toBe(before);
     });
 
-    test("changes when a helper file inside a directory declaration is edited or renamed", () => {
+    test("changes when config.json is edited", () => {
+      const pluginDir = makePlugin(FULL_DIGEST);
+      const before = parsePluginScheduleDeclarations(pluginDir, "p")
+        .declarations[0]!.definitionHash;
+      writeFileSync(
+        join(pluginDir, "schedules", "digest", "config.json"),
+        JSON.stringify({ expression: "0 10 * * *" }),
+      );
+      const after = parsePluginScheduleDeclarations(pluginDir, "p")
+        .declarations[0]!.definitionHash;
+      expect(after).not.toBe(before);
+    });
+
+    test("changes when the index.sh entrypoint is edited", () => {
+      const pluginDir = makePlugin({
+        "backup/config.json": JSON.stringify({ expression: "0 3 * * *" }),
+        "backup/index.sh": "echo v1\n",
+      });
+      const parse = () =>
+        parsePluginScheduleDeclarations(pluginDir, "p").declarations[0]!
+          .definitionHash;
+      const before = parse();
+      writeFileSync(
+        join(pluginDir, "schedules", "backup", "index.sh"),
+        "echo v2\n",
+      );
+      expect(parse()).not.toBe(before);
+    });
+
+    test("ignores every other file under the declaration directory", () => {
       const pluginDir = makePlugin({
         "backup/config.json": JSON.stringify({ expression: "0 3 * * *" }),
         "backup/index.sh": "sh lib/helper.sh\n",
-        "backup/lib/helper.sh": "echo v1\n",
       });
       const parse = () =>
         parsePluginScheduleDeclarations(pluginDir, "p").declarations[0]!
@@ -505,15 +533,50 @@ describe("parsePluginScheduleDeclarations", () => {
         "lib",
         "helper.sh",
       );
+      mkdirSync(dirname(helperPath), { recursive: true });
+      writeFileSync(helperPath, "echo v1\n");
+      const statePath = join(
+        pluginDir,
+        "schedules",
+        "backup",
+        "data",
+        "state.json",
+      );
+      mkdirSync(dirname(statePath), { recursive: true });
+      writeFileSync(statePath, JSON.stringify({ lastRun: 1 }));
+      expect(parse()).toBe(original);
+
       writeFileSync(helperPath, "echo v2\n");
-      const afterEdit = parse();
-      expect(afterEdit).not.toBe(original);
+      writeFileSync(statePath, JSON.stringify({ lastRun: 2 }));
+      expect(parse()).toBe(original);
 
       renameSync(
         helperPath,
         join(pluginDir, "schedules", "backup", "lib", "helper2.sh"),
       );
-      expect(parse()).not.toBe(afterEdit);
+      expect(parse()).toBe(original);
+
+      rmSync(join(pluginDir, "schedules", "backup", "data"), {
+        recursive: true,
+        force: true,
+      });
+      expect(parse()).toBe(original);
+    });
+
+    test("hashes a two-file declaration to its known value", () => {
+      const pluginDir = makePlugin({
+        "backup/config.json": JSON.stringify({ expression: "0 3 * * *" }),
+        "backup/index.sh": "echo backup\n",
+      });
+      // Pinned so stored rows keep their hash across upgrades. It holds only
+      // while the hashed paths stay `<name>/config.json` and
+      // `<name>/<entrypoint>`, relative to schedules/.
+      expect(
+        parsePluginScheduleDeclarations(pluginDir, "p").declarations[0]!
+          .definitionHash,
+      ).toBe(
+        "0b5722fc45abdd2c46672f275e3bcf548016ee5c0722da5a0588ef45fa7bbcab",
+      );
     });
 
     test("differs between two schedules with different names but same content", () => {

package/src/schedule/__tests__/plugin-schedule-reconciler.test.ts

@@ -45,9 +45,29 @@ mock.module("../../notifications/emit-signal.js", () => ({
   },
 }));
 
+/**
+ * Plugin directories the daemon has not activated. The reconciler arms only
+ * plugins this process brought up, and no test here runs the plugin loader, so
+ * the double answers "activated" unless a case says otherwise.
+ */
+const notActivatedDirs = new Set<string>();
+
+/** Every directory the reconciler put through the activation predicate. */
+const activationProbes: string[] = [];
+
+const realMtimeCache = await import("../../plugins/mtime-cache.js");
+mock.module("../../plugins/mtime-cache.js", () => ({
+  ...realMtimeCache,
+  isPluginDirActivated: (dir: string) => {
+    activationProbes.push(dir);
+    return !notActivatedDirs.has(dir);
+  },
+}));
+
 import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
 import { getDb } from "../../persistence/db-connection.js";
 import { initializeDb } from "../../persistence/db-init.js";
+import { listInstalledPluginDirs } from "../../plugins/installed-plugin-dirs.js";
 import { getWorkspacePluginsDir } from "../../util/platform.js";
 import {
   reconcilePluginSchedules,
@@ -175,6 +195,8 @@ function resetReconcilerFixtures(): void {
   emittedSignals.length = 0;
   emitResultOverride = null;
   emitGate = null;
+  notActivatedDirs.clear();
+  activationProbes.length = 0;
   resetDefinitionErrorEmitGuardForTests();
 }
 
@@ -970,6 +992,65 @@ describe("reconcilePluginSchedules", () => {
     expect(payload.reason).toContain("no upcoming occurrences");
   });
 
+  test("a plugin the daemon never activated arms nothing", async () => {
+    // Everything the parser needs is on disk; only the activation is missing,
+    // which is what a directory dropped into the plugins root looks like.
+    const dir = writePlugin("news", digest());
+    notActivatedDirs.add(dir);
+
+    await reconcilePluginSchedules();
+
+    expect(listDeclaredSchedules()).toHaveLength(0);
+    expect(emittedSignals).toHaveLength(0);
+  });
+
+  test("a row disarms once its plugin is no longer activated", async () => {
+    const dir = writePlugin("news", digest());
+    await reconcilePluginSchedules();
+    const created = listDeclaredSchedules()[0]!;
+    expect(created.enabled).toBe(true);
+
+    notActivatedDirs.add(dir);
+    await reconcilePluginSchedules();
+
+    const row = listDeclaredSchedules()[0]!;
+    expect(row.id).toBe(created.id);
+    expect(row.enabled).toBe(false);
+  });
+
+  test("a plugin activated between passes arms on the second one", async () => {
+    const dir = writePlugin("news", digest());
+    notActivatedDirs.add(dir);
+    await reconcilePluginSchedules();
+    expect(listDeclaredSchedules()).toHaveLength(0);
+
+    notActivatedDirs.delete(dir);
+    await reconcilePluginSchedules();
+
+    const rows = listDeclaredSchedules();
+    expect(rows).toHaveLength(1);
+    expect(rows[0]!.sourceKey).toBe(DIGEST_KEY);
+    expect(rows[0]!.enabled).toBe(true);
+    // The row arms for the first time here, so it announces its arrival.
+    const declared = emittedSignals.filter(
+      (s) => s.sourceEventName === "schedule.declared",
+    );
+    expect(declared).toHaveLength(1);
+    expect(declared[0]!.sourceContextId).toBe(DIGEST_KEY);
+  });
+
+  test("the activation probe sees the directory string the walk yields", async () => {
+    // The predicate is keyed by directory path, so the enumeration the
+    // reconciler walks and the map the daemon activates into have to agree on
+    // the exact string. Both come from `listInstalledPluginDirs`.
+    const dir = writePlugin("news", digest());
+
+    await reconcilePluginSchedules();
+
+    expect(listInstalledPluginDirs().map((p) => p.dir)).toEqual([dir]);
+    expect(activationProbes).toEqual([dir]);
+  });
+
   test("a suppressed error emit still latches the day guard", async () => {
     writePlugin("news", brokenDigest());
     emitResultOverride = {

package/src/schedule/plugin-schedule-availability.ts

@@ -0,0 +1,58 @@
+/**
+ * Availability probe for a plugin-declared schedule's source.
+ *
+ * Composes the daemon's activation state with the on-disk declaration probe:
+ * did this process bring the plugin up, and is its declaration still
+ * sourceable.
+ *
+ * **This probe is only meaningful in the main daemon process.** Activation is
+ * tracked in an in-memory map that `bringUpPlugin` writes, so only the process
+ * that ran the plugin loader can answer for it. HTTP routes and the plugin
+ * schedule reconciler run there, so they may use this. Worker processes (the
+ * schedule worker in `schedule/worker.ts`, sidecar turn workers) activate no
+ * plugins, so their ledger is empty and every plugin would read as
+ * unactivated. Those paths call {@link declarationExistsOnDisk} directly.
+ *
+ * That split is safe because the reconciler owns arming and runs in the
+ * daemon: a plugin it has not activated never arms, and its sweep disarms the
+ * rows of a plugin that stops being activated within one pass. The window
+ * between those passes is the whole exposure of the worker-side disk-only
+ * probes.
+ *
+ * The composition lives here rather than in `./plugin-schedule-declarations.ts`
+ * because that parser is reachable from the plugin loader's own static graph
+ * and must stay free of daemon runtime state. `plugins/mtime-cache.ts` reaches
+ * the schedule side only through a dynamic import, so importing it here does
+ * not close a static cycle.
+ */
+
+import { join } from "node:path";
+
+import { isPluginDirActivated } from "../plugins/mtime-cache.js";
+import { getWorkspacePluginsDir } from "../util/platform.js";
+import { declarationExistsOnDisk } from "./plugin-schedule-declarations.js";
+
+/**
+ * True when the schedule behind `sourceKey`
+ * (`plugin:<pluginName>/<scheduleName>`) may run: the daemon activated the
+ * plugin, and {@link declarationExistsOnDisk} still finds the declaration.
+ *
+ * The activation half is what keeps a plugin directory dropped into the
+ * plugins root out of the scheduler. Such a directory has files the disk probe
+ * accepts, but no `init` has run for it, so its hooks and tools are not live
+ * and its schedules must not be either.
+ */
+export async function pluginScheduleSourceAvailable(
+  sourceKey: string,
+): Promise<boolean> {
+  const match = /^plugin:([^/]+)\/(.+)$/.exec(sourceKey);
+  if (!match) {
+    return false;
+  }
+  const [, pluginName] = match;
+  const pluginDir = join(getWorkspacePluginsDir(), pluginName!);
+  return (
+    isPluginDirActivated(pluginDir) &&
+    (await declarationExistsOnDisk(sourceKey))
+  );
+}

package/src/schedule/plugin-schedule-declarations.ts

@@ -30,7 +30,6 @@ import { z } from "zod";
 import { isPluginDisabled } from "../plugins/disabled-state.js";
 import { parsePluginManifest } from "../plugins/external-plugin-loader.js";
 import { isInsidePluginRoot } from "../plugins/installed-plugin-dirs.js";
-import { walkPluginTree } from "../plugins/plugin-tree-walk.js";
 import { FRONTMATTER_REGEX } from "../skills/frontmatter.js";
 import { getWorkspacePluginsDir } from "../util/platform.js";
 import {
@@ -77,9 +76,13 @@ export interface ScheduleDeclaration {
   scriptInvocation: string | null;
   config: PluginScheduleConfig;
   /**
-   * Stable sha256 over the declaration's file contents and their paths
-   * relative to `schedules/`. Any edit, addition, removal, or rename of a
-   * declaration file changes the hash.
+   * Stable sha256 over the declaration's `config.json` and its entrypoint,
+   * each hashed together with its path relative to `schedules/`. Nothing else
+   * under the declaration directory takes part. Helper scripts, and any state
+   * a script writes beside itself, do not change the stored row definition, so
+   * hashing them would report a definition change every time a stateful
+   * schedule runs. Scripts execute by path, so an edit to a helper takes
+   * effect without a definition change.
    */
   definitionHash: string;
 }
@@ -292,21 +295,6 @@ function hashDeclarationFiles(files: DeclarationFile[]): string {
   return hash.digest("hex");
 }
 
-/**
- * Collect every regular file under `dir` (recursively, dot entries and
- * symlinks skipped) with paths relative to the schedules/ root.
- */
-function collectDeclarationFiles(
-  dir: string,
-  relPrefix: string,
-): DeclarationFile[] {
-  const files: DeclarationFile[] = [];
-  walkPluginTree(dir, { excludeDotEntries: true }, (rel, abs) => {
-    files.push({ relPath: `${relPrefix}${rel}`, content: readFileSync(abs) });
-  });
-  return files;
-}
-
 function shellQuote(value: string): string {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -395,25 +383,24 @@ function parseDirectoryDeclaration(
   let message: string | null = null;
   let scriptInvocation: string | null = null;
   let mode: PluginScheduleMode;
+  let entrypointText: string;
   if (entrypoint === "index.md") {
-    const content = readFileSync(join(dirPath, "index.md"), "utf8");
-    if (FRONTMATTER_REGEX.test(content)) {
+    entrypointText = readFileSync(join(dirPath, "index.md"), "utf8");
+    if (FRONTMATTER_REGEX.test(entrypointText)) {
       return {
         error:
           "index.md must not contain frontmatter: directory-form config belongs in config.json",
       };
     }
-    message = content.trim();
+    message = entrypointText.trim();
     if (!message) {
       return { error: "prompt body is empty" };
     }
     mode = "execute";
   } else {
     const scriptPath = join(dirPath, "index.sh");
-    scriptInvocation = buildScriptInvocation(
-      scriptPath,
-      readFileSync(scriptPath, "utf8"),
-    );
+    entrypointText = readFileSync(scriptPath, "utf8");
+    scriptInvocation = buildScriptInvocation(scriptPath, entrypointText);
     mode = "script";
   }
 
@@ -422,7 +409,16 @@ function parseDirectoryDeclaration(
     message,
     scriptInvocation,
     config: configResult.config,
-    files: collectDeclarationFiles(dirPath, `${dirName}/`),
+    files: [
+      {
+        relPath: `${dirName}/config.json`,
+        content: Buffer.from(rawConfigText),
+      },
+      {
+        relPath: `${dirName}/${entrypoint}`,
+        content: Buffer.from(entrypointText),
+      },
+    ],
   };
 }
 

package/src/schedule/plugin-schedule-reconciler.ts

@@ -33,6 +33,7 @@ import type { AttentionHints } from "../notifications/signal.js";
 import { isPluginDisabled } from "../plugins/disabled-state.js";
 import { parsePluginManifest } from "../plugins/external-plugin-loader.js";
 import { listInstalledPluginDirs } from "../plugins/installed-plugin-dirs.js";
+import { isPluginDirActivated } from "../plugins/mtime-cache.js";
 import { getLogger } from "../util/logger.js";
 import {
   type DeclarationError,
@@ -264,9 +265,14 @@ function isCompletedRecurrence(
  * as the plugin source collector) and gather their schedule declarations.
  * Identity = the directory basename, mirroring `parsePluginManifest`.
  *
- * Disabled plugins and plugins without a `schedules/` directory are skipped
- * entirely; in particular, only schedule-declaring plugins pay the manifest
- * parse each pass. A schedule-declaring plugin whose manifest fails
+ * Disabled plugins, plugins this daemon has not activated
+ * ({@link isPluginDirActivated}), and plugins without a `schedules/` directory
+ * are skipped entirely; in particular, only schedule-declaring plugins pay the
+ * manifest parse each pass. The activation gate is what keeps a directory
+ * dropped into the plugins root out of the desired set: nothing has run its
+ * `init`, so its hooks and tools are not live and its schedules must not arm
+ * either. It joins the set on the pass after the boot scan or an imperative
+ * reconcile brings it up. A schedule-declaring plugin whose manifest fails
  * `parsePluginManifest` (unreadable or schema-invalid `package.json`) also
  * contributes nothing to the desired set: the runtime loader refuses to
  * bring such a plugin up, so its schedules must not stay armed either. Each
@@ -282,6 +288,9 @@ async function collectDesiredDeclarations(): Promise<CollectedDeclarations> {
     if (isPluginDisabled(name)) {
       continue;
     }
+    if (!isPluginDirActivated(dir)) {
+      continue;
+    }
     if (!existsSync(join(dir, "schedules"))) {
       continue;
     }