@vellumai/assistant 0.10.3 → 0.10.4-staging.1

package/src/cli/commands/memory/worker.ts

@@ -7,18 +7,31 @@
  *
  * Subcommands:
  *
- *   - `start`  — spawn the worker process (detached, background).
- *   - `stop`   — send SIGTERM to the running worker process.
- *   - `status` — report whether the worker process is running.
+ *   - `start`  — spawn the worker process and enable `memory.worker.enabled`,
+ *     standing the daemon's synchronous in-process runner down.
+ *   - `stop`   — SIGTERM the worker process and disable `memory.worker.enabled`,
+ *     handing the queue back to the synchronous in-process runner.
+ *   - `status` — report the worker process state, the `memory.worker.enabled`
+ *     config value, and whether the synchronous in-process runner is going.
  *
  * All three run directly in the CLI process (transport: "local") — no IPC
- * round-trip to the daemon.
+ * round-trip to the daemon. The daemon's worker supervisor re-reads
+ * `memory.worker.enabled` each poll and stands its synchronous runner down (or
+ * resumes it) accordingly, so flipping the flag here switches the running
+ * daemon's mode without a restart.
  */
 
 import type { Command } from "commander";
 
+import {
+  getConfigReadOnly,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../../config/loader.js";
 import {
   probeMemoryWorker,
+  probeSyncRunner,
   spawnMemoryWorkerProcess,
 } from "../../../memory/worker-control.js";
 import { getMemoryWorkerPidPath } from "../../../util/platform.js";
@@ -26,6 +39,17 @@ import { registerCommand } from "../../lib/register-command.js";
 import { log } from "../../logger.js";
 import { shouldOutputJson, writeOutput } from "../../output.js";
 
+/**
+ * Persist `memory.worker.enabled` to the on-disk config via the shared
+ * raw-config helpers, so only this leaf changes (schema defaults are not baked
+ * into the file). The assistant picks the change up on its next config read.
+ */
+function setWorkerEnabled(enabled: boolean): void {
+  const raw = loadRawConfig();
+  setNestedValue(raw, "memory.worker.enabled", enabled);
+  saveRawConfig(raw);
+}
+
 // ---------------------------------------------------------------------------
 // `start`
 // ---------------------------------------------------------------------------
@@ -38,6 +62,9 @@ async function startWorker(
   try {
     result = await spawnMemoryWorkerProcess();
   } catch (err) {
+    // Spawn failed — leave `memory.worker.enabled` untouched so the daemon's
+    // synchronous runner keeps draining the queue rather than standing down
+    // for a worker that never came up.
     const msg = err instanceof Error ? err.message : String(err);
     if (shouldOutputJson(cmd)) {
       writeOutput(cmd, { ok: false, error: msg });
@@ -48,25 +75,28 @@ async function startWorker(
     return;
   }
 
-  if (result.alreadyRunning) {
-    const msg = `Memory worker is already running (PID ${result.pid})`;
-    if (shouldOutputJson(cmd)) {
-      writeOutput(cmd, { ok: false, error: msg, pid: result.pid });
-    } else {
-      log.error(msg);
-    }
-    process.exitCode = 1;
-    return;
-  }
+  // The worker process is up (freshly spawned or already running). Enable the
+  // flag so the daemon's supervisor stands its synchronous runner down (and so
+  // the daemon spawns the worker again on the next restart).
+  setWorkerEnabled(true);
 
   if (shouldOutputJson(cmd)) {
     writeOutput(cmd, {
       ok: true,
       pid: result.pid,
+      alreadyRunning: result.alreadyRunning,
       pidPath: getMemoryWorkerPidPath(),
+      workerEnabled: true,
     });
   } else {
-    log.info(`Memory worker started (PID ${result.pid})`);
+    log.info(
+      result.alreadyRunning
+        ? `Memory worker is already running (PID ${result.pid})`
+        : `Memory worker started (PID ${result.pid})`,
+    );
+    log.info(
+      "Enabled memory.worker.enabled; the synchronous in-process runner will stand down",
+    );
   }
 }
 
@@ -75,15 +105,28 @@ async function startWorker(
 // ---------------------------------------------------------------------------
 
 function stopWorker(opts: { json?: boolean }, cmd: Command): void {
+  // Persist the preference first: `stop` means "hand the queue back to the
+  // synchronous in-process runner." Disabling the flag makes the daemon's
+  // supervisor resume processing in-process on its next poll and lines the next
+  // daemon restart up with synchronous mode; the SIGTERM below then stops the
+  // now-redundant worker process.
+  setWorkerEnabled(false);
+
   const current = probeMemoryWorker();
   if (current.status !== "running" || current.pid == null) {
-    const msg = "Memory worker is not running";
+    // No worker process to signal — flipping the flag alone restores
+    // synchronous mode, so this is success, not an error.
     if (shouldOutputJson(cmd)) {
-      writeOutput(cmd, { ok: false, error: msg });
+      writeOutput(cmd, {
+        ok: true,
+        workerWasRunning: false,
+        workerEnabled: false,
+      });
     } else {
-      log.error(msg);
+      log.info(
+        "Memory worker process was not running; disabled memory.worker.enabled (synchronous runner active)",
+      );
     }
-    process.exitCode = 1;
     return;
   }
 
@@ -93,7 +136,7 @@ function stopWorker(opts: { json?: boolean }, cmd: Command): void {
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     if (shouldOutputJson(cmd)) {
-      writeOutput(cmd, { ok: false, error: msg, pid });
+      writeOutput(cmd, { ok: false, error: msg, pid, workerEnabled: false });
     } else {
       log.error(`Failed to stop memory worker (PID ${pid}): ${msg}`);
     }
@@ -102,9 +145,12 @@ function stopWorker(opts: { json?: boolean }, cmd: Command): void {
   }
 
   if (shouldOutputJson(cmd)) {
-    writeOutput(cmd, { ok: true, pid });
+    writeOutput(cmd, { ok: true, pid, workerEnabled: false });
   } else {
     log.info(`Memory worker stop signal sent (PID ${pid})`);
+    log.info(
+      "Disabled memory.worker.enabled; the synchronous in-process runner will take over",
+    );
   }
 }
 
@@ -113,14 +159,25 @@ function stopWorker(opts: { json?: boolean }, cmd: Command): void {
 // ---------------------------------------------------------------------------
 
 function statusWorker(opts: { json?: boolean }, cmd: Command): void {
-  const result = probeMemoryWorker();
+  const worker = probeMemoryWorker();
+  const syncRunner = probeSyncRunner();
+  const workerEnabled = getConfigReadOnly().memory.worker.enabled;
+
   if (shouldOutputJson(cmd)) {
-    writeOutput(cmd, result);
+    writeOutput(cmd, { ...worker, workerEnabled, syncRunner });
   } else {
-    if (result.status === "running") {
-      log.info(`Memory worker is running (PID ${result.pid})`);
+    if (worker.status === "running") {
+      log.info(`Memory worker process is running (PID ${worker.pid})`);
     } else {
-      log.info("Memory worker is not running");
+      log.info("Memory worker process is not running");
+    }
+    log.info(`memory.worker.enabled: ${workerEnabled}`);
+    if (syncRunner.status === "running") {
+      log.info(
+        `Synchronous in-process runner is running (PID ${syncRunner.pid})`,
+      );
+    } else {
+      log.info("Synchronous in-process runner is not running");
     }
   }
 }
@@ -139,7 +196,11 @@ export function registerMemoryWorkerCommand(memory: Command): void {
         "after",
         `
 The memory worker processes embedding, consolidation, and cleanup jobs in a
-separate OS process so they do not block the daemon's main event loop.
+separate OS process so they do not block the assistant's main event loop.
+
+\`start\` enables memory.worker.enabled and \`stop\` disables it, so the
+assistant's synchronous in-process runner stands down (start) or takes back over
+(stop) without a restart.
 
 Examples:
   $ assistant memory worker start
@@ -149,7 +210,9 @@ Examples:
 
       worker
         .command("start")
-        .description("Start the memory worker as a background process")
+        .description(
+          "Start the memory worker process and enable memory.worker.enabled",
+        )
         .option("--json", "Emit raw JSON instead of a formatted summary")
         .action(async (opts: { json?: boolean }, cmd: Command) => {
           await startWorker(opts, cmd);
@@ -157,7 +220,9 @@ Examples:
 
       worker
         .command("stop")
-        .description("Stop the running memory worker process")
+        .description(
+          "Stop the memory worker process and disable memory.worker.enabled",
+        )
         .option("--json", "Emit raw JSON instead of a formatted summary")
         .action((opts: { json?: boolean }, cmd: Command) => {
           stopWorker(opts, cmd);
@@ -165,7 +230,9 @@ Examples:
 
       worker
         .command("status")
-        .description("Check whether the memory worker process is running")
+        .description(
+          "Report worker process state, memory.worker.enabled, and the synchronous runner",
+        )
         .option("--json", "Emit raw JSON instead of a formatted summary")
         .action((opts: { json?: boolean }, cmd: Command) => {
           statusWorker(opts, cmd);

package/src/cli/commands/plugins.ts

@@ -42,17 +42,7 @@ import {
   PluginPinHistoryError,
   resolvePinToMarketplaceCommit,
 } from "../lib/plugin-pin-history.js";
-import {
-  buildPublishPayload,
-  findPluginRoot,
-  formatPayloadForPrint,
-  formatPublishResult,
-  formatValidationResult,
-  postPublishRequest,
-  resolveGitContext,
-  resolvePlatformDeps,
-  validatePluginForPublish,
-} from "../lib/publish-plugin.js";
+import { runPublish } from "../lib/publish-plugin.js";
 import { registerCommand } from "../lib/register-command.js";
 import {
   InvalidSearchPatternError,
@@ -561,141 +551,8 @@ $ assistant plugins publish --json`,
             json?: boolean;
             category?: string;
           }) => {
-            // 1. Find the plugin root
-            const searchDir = opts.path ?? process.cwd();
-            const pluginDir = findPluginRoot(searchDir);
-            if (!pluginDir) {
-              console.error(
-                `No package.json found in ${searchDir} or any parent directory.`,
-              );
-              process.exitCode = 1;
-              return;
-            }
-
-            // 2. Validate the plugin
-            const validation = validatePluginForPublish(pluginDir);
-            if (!validation.valid) {
-              if (opts.json) {
-                process.stdout.write(
-                  JSON.stringify({ ok: false, errors: validation.issues }) +
-                    "\n",
-                );
-              } else {
-                console.error(formatValidationResult(validation));
-              }
-              process.exitCode = 1;
-              return;
-            }
-
-            if (!opts.json && validation.warnings.length > 0) {
-              console.warn(formatValidationResult(validation));
-            }
-
-            // 3. Resolve git context
-            let git;
-            try {
-              git = await resolveGitContext(pluginDir);
-            } catch (err) {
-              const message = err instanceof Error ? err.message : String(err);
-              console.error(`Git context resolution failed: ${message}`);
-              process.exitCode = 1;
-              return;
-            }
-
-            if (git.dirty) {
-              console.warn(
-                "Warning: working tree is dirty. The pinned commit SHA should match a clean, pushed commit.",
-              );
-            }
-
-            if (!git.pushed) {
-              console.error(
-                `Commit ${git.sha.slice(0, 7)} has not been pushed to the remote. Push your changes first.`,
-              );
-              process.exitCode = 1;
-              return;
-            }
-
-            // 4. Determine category
-            const category = opts.category ?? "other";
-
-            // 5. Build the payload
-            const payload = buildPublishPayload(validation, git, category);
-
-            // 6. Handle --print mode
-            if (opts.print) {
-              if (opts.json) {
-                process.stdout.write(
-                  JSON.stringify({ ok: true, payload }) + "\n",
-                );
-              } else {
-                console.log(formatPayloadForPrint(payload));
-              }
-              return;
-            }
-
-            // 7. Confirm before submitting (unless --force or --json)
-            if (!opts.force && !opts.json) {
-              console.log("\nPlugin entry to submit:");
-              console.log(formatPayloadForPrint(payload));
-              console.log("");
-              const result = await confirmPrompt({
-                question: "Submit this entry to the Vellum marketplace? [y/N] ",
-                isTTY: Boolean(process.stdin.isTTY),
-                refuseNonInteractiveMessage:
-                  "Refusing to publish non-interactively. Pass --force to confirm.",
-              });
-              if (result === "non-interactive") {
-                process.exitCode = 1;
-                return;
-              }
-            }
-
-            // 8. Submit to the platform API
-            const deps = await resolvePlatformDeps();
-            if (!deps) {
-              const msg =
-                "Not connected to Vellum platform. Run `assistant platform connect` to connect, or use --print to generate the entry without submitting.";
-              if (opts.json) {
-                process.stdout.write(
-                  JSON.stringify({
-                    ok: false,
-                    error: "not_connected",
-                    message: msg,
-                  }) + "\n",
-                );
-              } else {
-                console.error(msg);
-              }
-              process.exitCode = 1;
-              return;
-            }
-
-            try {
-              const result = await postPublishRequest(payload, deps);
-
-              if (opts.json) {
-                process.stdout.write(JSON.stringify(result) + "\n");
-              } else {
-                console.log(formatPublishResult(result));
-              }
-
-              if (!result.ok) process.exitCode = 1;
-            } catch (err) {
-              const message = err instanceof Error ? err.message : String(err);
-              if (opts.json) {
-                process.stdout.write(
-                  JSON.stringify({
-                    ok: false,
-                    error: "request_failed",
-                    message,
-                  }) + "\n",
-                );
-              } else {
-                console.error(`Publish request failed: ${message}`);
-              }
-              process.exitCode = 1;
-            }
+            const ok = await runPublish(opts, { confirmPrompt });
+            if (!ok) process.exitCode = 1;
           },
         );
 

package/src/cli/lib/__tests__/list-installed-plugins.test.ts

@@ -157,8 +157,8 @@ describe("listAllPlugins", () => {
   test("includes default plugins with source=default", () => {
     const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
     const defaults = result.filter((p) => p.source === "default");
-    // All 15 default plugins should be present.
-    expect(defaults.length).toBe(15);
+    // All 14 default plugins should be present.
+    expect(defaults.length).toBe(14);
     // Names should all start with "default-".
     expect(defaults.every((p) => p.name.startsWith("default-"))).toBe(true);
     // None should be disabled by default in a fresh temp dir.
@@ -212,24 +212,24 @@ describe("listAllPlugins", () => {
   });
 
   test("detects disabled state for default plugins via stub directory", () => {
-    mkdirSync(join(pluginsDir, "default-advisor"), { recursive: true });
-    writeFileSync(join(pluginsDir, "default-advisor", ".disabled"), "");
+    mkdirSync(join(pluginsDir, "default-compaction"), { recursive: true });
+    writeFileSync(join(pluginsDir, "default-compaction", ".disabled"), "");
 
     const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
-    const advisor = result.find((p) => p.name === "default-advisor");
-    expect(advisor).toBeDefined();
-    expect(advisor!.disabled).toBe(true);
+    const compaction = result.find((p) => p.name === "default-compaction");
+    expect(compaction).toBeDefined();
+    expect(compaction!.disabled).toBe(true);
   });
 
   test("default stub directory is excluded from user listing", () => {
-    mkdirSync(join(pluginsDir, "default-advisor"), { recursive: true });
-    writeFileSync(join(pluginsDir, "default-advisor", ".disabled"), "");
+    mkdirSync(join(pluginsDir, "default-compaction"), { recursive: true });
+    writeFileSync(join(pluginsDir, "default-compaction", ".disabled"), "");
 
     const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
     // Should appear exactly once, as a default entry (not a user entry).
-    const advisorEntries = result.filter((p) => p.name === "default-advisor");
-    expect(advisorEntries).toHaveLength(1);
-    expect(advisorEntries[0]!.source).toBe("default");
+    const compactionEntries = result.filter((p) => p.name === "default-compaction");
+    expect(compactionEntries).toHaveLength(1);
+    expect(compactionEntries[0]!.source).toBe("default");
   });
 
   test("sort order: enabled user, disabled user, enabled default, disabled default", () => {
@@ -247,8 +247,8 @@ describe("listAllPlugins", () => {
     writeFileSync(join(pluginsDir, "bbb-disabled", ".disabled"), "");
 
     // Disable one default plugin
-    mkdirSync(join(pluginsDir, "default-advisor"), { recursive: true });
-    writeFileSync(join(pluginsDir, "default-advisor", ".disabled"), "");
+    mkdirSync(join(pluginsDir, "default-compaction"), { recursive: true });
+    writeFileSync(join(pluginsDir, "default-compaction", ".disabled"), "");
 
     const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
 
@@ -306,8 +306,8 @@ describe("listAllPlugins", () => {
 
   test("default plugins have version from their manifest", () => {
     const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
-    const advisor = result.find((p) => p.name === "default-advisor");
-    expect(advisor).toBeDefined();
-    expect(advisor!.packageJson?.version).toBeTruthy();
+    const compaction = result.find((p) => p.name === "default-compaction");
+    expect(compaction).toBeDefined();
+    expect(compaction!.packageJson?.version).toBeTruthy();
   });
 });

package/src/cli/lib/__tests__/publish-plugin.test.ts

@@ -11,6 +11,7 @@ import {
   formatValidationResult,
   type ParsedPackageJson,
   type PublishValidation,
+  runPublish,
   validatePluginForPublish,
 } from "../publish-plugin.js";
 
@@ -200,6 +201,7 @@ describe("buildPublishPayload", () => {
       repo: "me/my-plugin",
       dirty: false,
       pushed: true,
+      pluginPath: "",
     };
 
     const payload = buildPublishPayload(validation, git, "productivity");
@@ -208,12 +210,37 @@ describe("buildPublishPayload", () => {
     expect(payload.source.source).toBe("github");
     expect(payload.source.repo).toBe("me/my-plugin");
     expect(payload.source.ref).toBe("e83c5163316f89bfbde7d9ab23ca2e25604af290");
+    expect(payload.source.path).toBeUndefined();
     expect(payload.category).toBe("productivity");
     expect(payload.description).toBe("Does cool stuff");
     expect(payload.license).toBe("MIT");
     expect(payload.homepage).toBe("https://github.com/me/my-plugin");
   });
 
+  it("sets source.path for nested plugin roots", () => {
+    const validation: PublishValidation = {
+      valid: true,
+      issues: [],
+      warnings: [],
+      packageJson: {
+        name: "my-plugin",
+        version: "1.0.0",
+        peerDependencies: { "@vellumai/plugin-api": "^1.0.0" },
+      },
+      pluginDir: "/tmp/monorepo/packages/plugin",
+    };
+    const git = {
+      sha: "e83c5163316f89bfbde7d9ab23ca2e25604af290",
+      repo: "me/monorepo",
+      dirty: false,
+      pushed: true,
+      pluginPath: "packages/plugin",
+    };
+
+    const payload = buildPublishPayload(validation, git, "other");
+    expect(payload.source.path).toBe("packages/plugin");
+  });
+
   it("extracts homepage from repository.url when homepage is absent", () => {
     const validation: PublishValidation = {
       valid: true,
@@ -232,6 +259,7 @@ describe("buildPublishPayload", () => {
       repo: "me/my-plugin",
       dirty: false,
       pushed: true,
+      pluginPath: "",
     };
 
     const payload = buildPublishPayload(validation, git, "other");
@@ -304,3 +332,73 @@ describe("formatValidationResult", () => {
     expect(result).toContain("passed");
   });
 });
+
+// ---------------------------------------------------------------------------
+// runPublish (CLI entrypoint)
+// ---------------------------------------------------------------------------
+
+describe("runPublish", () => {
+  it("returns false on denied confirmation without submitting", async () => {
+    const dir = makePluginDir(tmpdir(), validPkg, { hooks: true });
+    // Initialize a git repo so resolveGitContext doesn't fail
+    const { execSync } = await import("node:child_process");
+    const gitEnv = {
+      ...process.env,
+      GIT_AUTHOR_NAME: "Test",
+      GIT_AUTHOR_EMAIL: "test@test.com",
+      GIT_COMMITTER_NAME: "Test",
+      GIT_COMMITTER_EMAIL: "test@test.com",
+    };
+    execSync("git init && git add -A && git commit -m init", {
+      cwd: dir,
+      stdio: "ignore",
+      env: gitEnv,
+    });
+    execSync("git remote add origin https://github.com/test/test-plugin.git", {
+      cwd: dir,
+      stdio: "ignore",
+      env: gitEnv,
+    });
+
+    const ok = await runPublish(
+      { path: dir, force: false, json: false },
+      {
+        confirmPrompt: async () => "denied",
+      },
+    );
+
+    expect(ok).toBe(false);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("returns true on --print without submitting", async () => {
+    const dir = makePluginDir(tmpdir(), validPkg, { hooks: true });
+
+    const ok = await runPublish(
+      { path: dir, print: true, json: true },
+      {
+        confirmPrompt: async () => {
+          throw new Error("should not be called");
+        },
+      },
+    );
+
+    expect(ok).toBe(true);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("returns false when no package.json found", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "no-pkg-"));
+    const ok = await runPublish(
+      { path: dir, force: true, json: true },
+      {
+        confirmPrompt: async () => {
+          throw new Error("should not be called");
+        },
+      },
+    );
+
+    expect(ok).toBe(false);
+    rmSync(dir, { recursive: true });
+  });
+});