@vellumai/assistant 0.6.1 → 0.6.2

package/src/__tests__/workspace-migration-030-seed-pkb-autoinject.test.ts

@@ -0,0 +1,168 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { seedPkbAutoinjectMigration } from "../workspace/migrations/030-seed-pkb-autoinject.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let workspaceDir: string;
+let pkbDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-030-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  pkbDir = join(workspaceDir, "pkb");
+  mkdirSync(pkbDir, { recursive: true });
+}
+
+// ---------------------------------------------------------------------------
+// Setup / Teardown
+// ---------------------------------------------------------------------------
+
+const dirs: string[] = [];
+
+beforeEach(() => {
+  freshWorkspace();
+  dirs.push(workspaceDir);
+});
+
+afterEach(() => {
+  for (const dir of dirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("030-seed-pkb-autoinject migration", () => {
+  test("has correct migration id", () => {
+    expect(seedPkbAutoinjectMigration.id).toBe("030-seed-pkb-autoinject");
+  });
+
+  // ─── run() ──────────────────────────────────────────────────────────────
+
+  test("creates _autoinject.md with default content", () => {
+    seedPkbAutoinjectMigration.run(workspaceDir);
+
+    const filePath = join(pkbDir, "_autoinject.md");
+    expect(existsSync(filePath)).toBe(true);
+
+    const content = readFileSync(filePath, "utf-8");
+    expect(content).toContain("INDEX.md");
+    expect(content).toContain("essentials.md");
+    expect(content).toContain("threads.md");
+    expect(content).toContain("buffer.md");
+  });
+
+  test("no-op when pkb/ does not exist", () => {
+    rmSync(pkbDir, { recursive: true, force: true });
+    seedPkbAutoinjectMigration.run(workspaceDir);
+    expect(existsSync(join(pkbDir, "_autoinject.md"))).toBe(false);
+  });
+
+  test("idempotent — does not overwrite existing _autoinject.md", () => {
+    const customContent = "INDEX.md\ncustom-topic.md\n";
+    writeFileSync(join(pkbDir, "_autoinject.md"), customContent, "utf-8");
+
+    seedPkbAutoinjectMigration.run(workspaceDir);
+
+    const content = readFileSync(join(pkbDir, "_autoinject.md"), "utf-8");
+    expect(content).toBe(customContent);
+  });
+
+  test("appends _autoinject.md entry to INDEX.md", () => {
+    const indexContent =
+      "# Knowledge Base\n\n## Always Loaded\n" +
+      "- essentials.md — Core facts\n" +
+      "- threads.md — Active threads\n" +
+      "- buffer.md — Inbox\n\n" +
+      "## Topics\n";
+    writeFileSync(join(pkbDir, "INDEX.md"), indexContent, "utf-8");
+
+    seedPkbAutoinjectMigration.run(workspaceDir);
+
+    const updated = readFileSync(join(pkbDir, "INDEX.md"), "utf-8");
+    expect(updated).toContain("_autoinject.md");
+    // Should appear after buffer.md
+    const bufferIdx = updated.indexOf("buffer.md");
+    const autoinjectIdx = updated.indexOf("_autoinject.md");
+    expect(autoinjectIdx).toBeGreaterThan(bufferIdx);
+  });
+
+  test("does not duplicate _autoinject.md entry in INDEX.md", () => {
+    const indexContent =
+      "# Knowledge Base\n\n## Always Loaded\n" +
+      "- buffer.md — Inbox\n" +
+      "- _autoinject.md — Controls autoinjection\n\n" +
+      "## Topics\n";
+    writeFileSync(join(pkbDir, "INDEX.md"), indexContent, "utf-8");
+
+    seedPkbAutoinjectMigration.run(workspaceDir);
+
+    const updated = readFileSync(join(pkbDir, "INDEX.md"), "utf-8");
+    const matches = updated.match(/_autoinject\.md/g);
+    expect(matches?.length).toBe(1);
+  });
+
+  test("handles missing INDEX.md gracefully", () => {
+    // No INDEX.md — should still create _autoinject.md without error
+    seedPkbAutoinjectMigration.run(workspaceDir);
+    expect(existsSync(join(pkbDir, "_autoinject.md"))).toBe(true);
+  });
+
+  // ─── down() ─────────────────────────────────────────────────────────────
+
+  describe("down()", () => {
+    test("removes _autoinject.md when content matches template", () => {
+      seedPkbAutoinjectMigration.run(workspaceDir);
+      expect(existsSync(join(pkbDir, "_autoinject.md"))).toBe(true);
+
+      seedPkbAutoinjectMigration.down(workspaceDir);
+      expect(existsSync(join(pkbDir, "_autoinject.md"))).toBe(false);
+    });
+
+    test("preserves _autoinject.md when user has customized it", () => {
+      const customContent = "INDEX.md\nmy-custom-file.md\n";
+      writeFileSync(join(pkbDir, "_autoinject.md"), customContent, "utf-8");
+
+      seedPkbAutoinjectMigration.down(workspaceDir);
+
+      expect(existsSync(join(pkbDir, "_autoinject.md"))).toBe(true);
+      expect(readFileSync(join(pkbDir, "_autoinject.md"), "utf-8")).toBe(
+        customContent,
+      );
+    });
+
+    test("no-op when _autoinject.md does not exist", () => {
+      seedPkbAutoinjectMigration.down(workspaceDir);
+      // Should not throw
+    });
+
+    test("no-op when pkb/ does not exist", () => {
+      rmSync(pkbDir, { recursive: true, force: true });
+      seedPkbAutoinjectMigration.down(workspaceDir);
+      // Should not throw
+    });
+
+    test("idempotent — calling down() twice is safe", () => {
+      seedPkbAutoinjectMigration.run(workspaceDir);
+      seedPkbAutoinjectMigration.down(workspaceDir);
+      seedPkbAutoinjectMigration.down(workspaceDir);
+      // Should not throw
+    });
+  });
+});

package/src/__tests__/workspace-policy.test.ts

@@ -198,7 +198,7 @@ describe("isWorkspaceScopedInvocation", () => {
   // ── Bash ───────────────────────────────────────────────────────────
 
   describe("bash", () => {
-    test("returns true (sandbox handles isolation)", () => {
+    test("returns true (container handles isolation)", () => {
       expect(
         isWorkspaceScopedInvocation(
           "bash",
@@ -255,12 +255,7 @@ describe("isWorkspaceScopedInvocation", () => {
   // ── Always-scoped safe tools ───────────────────────────────────────
 
   describe("always-scoped tools", () => {
-    const safeTools = [
-      "skill_load",
-      "recall",
-      "ui_update",
-      "ui_dismiss",
-    ];
+    const safeTools = ["skill_load", "recall", "ui_update", "ui_dismiss"];
 
     for (const tool of safeTools) {
       test(`${tool} is workspace-scoped`, () => {

package/src/agent/loop.ts

@@ -201,7 +201,6 @@ export class AgentLoop {
   ): Promise<Message[]> {
     const history = [...messages];
     let toolUseTurns = 0;
-    let nudgedForEmptyResponse = false;
     let consecutiveErrorTurns = 0;
     let lastLlmCallTime = 0;
     const rlog = requestId ? log.child({ requestId }) : log;
@@ -403,35 +402,7 @@ export class AgentLoop {
             block.type === "tool_use",
         );
 
-        // Check if the assistant turn contained any visible text (used for
-        // the empty-response nudge).
-        const hasTextBlock = response.content.some(
-          (block) => block.type === "text" && block.text.trim().length > 0,
-        );
-
         if (toolUseBlocks.length === 0 || !this.toolExecutor) {
-          // Check if the LLM returned no text after tool results — nudge it to respond
-          const lastUserMsg =
-            history.length >= 2 ? history[history.length - 2] : undefined;
-          const lastWasToolResult =
-            lastUserMsg?.role === "user" &&
-            lastUserMsg.content.some((block) => block.type === "tool_result");
-
-          if (!hasTextBlock && lastWasToolResult && !nudgedForEmptyResponse) {
-            nudgedForEmptyResponse = true;
-            history.push({
-              role: "user",
-              content: [
-                {
-                  type: "text",
-                  text: "<system_notice>You executed tools but didn't tell the user what happened. Provide a brief, conversational summary of the results.</system_notice>",
-                },
-              ],
-            });
-            continue;
-          }
-
-          // No tool calls or no executor — done
           break;
         }
 

package/src/channels/types.ts

@@ -90,6 +90,11 @@ export function isInteractiveInterface(id: InterfaceId): boolean {
   return INTERACTIVE_INTERFACES.has(id);
 }
 
+/** Whether the interface supports host proxies (bash, file, computer-use). */
+export function supportsHostProxy(id: InterfaceId): boolean {
+  return id === "macos";
+}
+
 export interface TurnInterfaceContext {
   userMessageInterface: InterfaceId;
   assistantMessageInterface: InterfaceId;

package/src/cli/__tests__/run-assistant-command.ts

@@ -1,17 +1,32 @@
+export interface AssistantCommandResult {
+  stdout: string;
+  stderr: string;
+}
+
 /**
  * CLI test utility — run an assistant CLI command via the real program,
- * capturing stdout.
+ * capturing stdout and stderr.
+ *
+ * Returns both stdout and stderr. For backward compatibility, the function
+ * is also callable with just a string return (use `runAssistantCommand`).
  */
-export async function runAssistantCommand(...args: string[]): Promise<string> {
+export async function runAssistantCommandFull(
+  ...args: string[]
+): Promise<AssistantCommandResult> {
   const { buildCliProgram } = await import("../program.js");
-  const program = buildCliProgram();
+  const program = await buildCliProgram();
   program.exitOverride();
-  program.configureOutput({ writeErr: () => {}, writeOut: () => {} });
 
-  const chunks: string[] = [];
+  const stderrChunks: string[] = [];
+  program.configureOutput({
+    writeErr: (str: string) => stderrChunks.push(str),
+    writeOut: () => {},
+  });
+
+  const stdoutChunks: string[] = [];
   const originalWrite = process.stdout.write;
   process.stdout.write = ((chunk: string | Uint8Array) => {
-    chunks.push(
+    stdoutChunks.push(
       typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk),
     );
     return true;
@@ -25,5 +40,17 @@ export async function runAssistantCommand(...args: string[]): Promise<string> {
     process.stdout.write = originalWrite;
   }
 
-  return chunks.join("");
+  return {
+    stdout: stdoutChunks.join(""),
+    stderr: stderrChunks.join(""),
+  };
+}
+
+/**
+ * CLI test utility — run an assistant CLI command via the real program,
+ * capturing stdout (backward-compatible wrapper).
+ */
+export async function runAssistantCommand(...args: string[]): Promise<string> {
+  const result = await runAssistantCommandFull(...args);
+  return result.stdout;
 }

package/src/cli/__tests__/unknown-command.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "bun:test";
+
+import { runAssistantCommandFull } from "./run-assistant-command.js";
+
+describe("unknown command handling", () => {
+  it("reports an error for an unknown subcommand", async () => {
+    const { stderr } = await runAssistantCommandFull("invalid");
+
+    expect(stderr).toContain("unknown command 'invalid'");
+    expect(stderr).toContain("Run 'assistant --help'");
+  });
+
+  it("reports an error for an unknown subcommand with extra arguments", async () => {
+    const { stderr } = await runAssistantCommandFull("invalid", "something");
+
+    expect(stderr).toContain("unknown command 'invalid'");
+    expect(stderr).toContain("Run 'assistant --help'");
+  });
+
+  it("suggests a similar command when the input is close", async () => {
+    const { stderr } = await runAssistantCommandFull("confg");
+
+    expect(stderr).toContain("unknown command 'confg'");
+    expect(stderr).toContain("Did you mean 'config'");
+  });
+
+  it("does not suggest a command when the input is too far off", async () => {
+    const { stderr } = await runAssistantCommandFull("xyzzy");
+
+    expect(stderr).toContain("unknown command 'xyzzy'");
+    expect(stderr).not.toContain("Did you mean");
+  });
+});

package/src/cli/commands/default-action.ts

@@ -5,10 +5,77 @@ import { shouldAutoStartDaemon } from "../../daemon/connection-policy.js";
 import { ensureDaemonRunning } from "../../daemon/lifecycle.js";
 
 export function registerDefaultAction(program: Command): void {
-  program.action(async () => {
+  program.action(async (_options: unknown, cmd: Command) => {
+    // Commander routes unknown subcommands to the root action as positional
+    // args instead of raising an error. Detect this case and fail with a
+    // helpful message so users don't silently get the interactive CLI when
+    // they mistype a command name.
+    if (cmd.args.length > 0) {
+      const unknown = cmd.args[0];
+      const available = cmd.commands.map((c) => c.name());
+      const suggestion = findClosestCommand(unknown, available);
+      const lines = [`unknown command '${unknown}'`];
+      if (suggestion) {
+        lines.push(`(Did you mean '${suggestion}'?)`);
+      }
+      lines.push(`Run 'assistant --help' to see a list of available commands.`);
+      cmd.error(lines.join("\n"), {
+        code: "commander.unknownCommand",
+        exitCode: 1,
+      });
+      return;
+    }
+
     if (shouldAutoStartDaemon()) {
       await ensureDaemonRunning();
     }
     await startCli();
   });
 }
+
+/**
+ * Find the closest matching command name using Levenshtein distance.
+ * Returns the best match if the distance is ≤ 40% of the longer string's
+ * length, otherwise returns undefined.
+ */
+function findClosestCommand(
+  input: string,
+  candidates: string[],
+): string | undefined {
+  let best: string | undefined;
+  let bestDist = Infinity;
+
+  for (const name of candidates) {
+    const dist = levenshtein(input.toLowerCase(), name.toLowerCase());
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = name;
+    }
+  }
+
+  // Only suggest if the edit distance is at most 40% of the longer string
+  const maxLen = Math.max(input.length, best?.length ?? 0);
+  if (best && bestDist <= Math.ceil(maxLen * 0.4)) {
+    return best;
+  }
+  return undefined;
+}
+
+function levenshtein(a: string, b: string): number {
+  const m = a.length;
+  const n = b.length;
+  const dp: number[][] = Array.from({ length: m + 1 }, () =>
+    Array(n + 1).fill(0),
+  );
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] =
+        a[i - 1] === b[j - 1]
+          ? dp[i - 1][j - 1]
+          : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    }
+  }
+  return dp[m][n];
+}

package/src/cli/commands/oauth/__tests__/connect.test.ts

@@ -668,6 +668,33 @@ describe("assistant oauth connect", () => {
     expect(parsed.error).toContain("apps upsert");
   });
 
+  // -------------------------------------------------------------------------
+  // Manual-token providers (slack_channel, telegram)
+  // -------------------------------------------------------------------------
+
+  test("manual-token provider returns error directing to credentials command", async () => {
+    mockGetProvider = () => ({
+      providerKey: "slack_channel",
+      authUrl: "urn:manual-token",
+      tokenUrl: "urn:manual-token",
+      managedServiceConfigKey: null,
+    });
+    mockIsManagedMode = () => false;
+
+    const { exitCode, stdout } = await runCommand([
+      "connect",
+      "slack_channel",
+      "--json",
+    ]);
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("manual token configuration");
+    expect(parsed.error).toContain("assistant credentials set");
+    expect(parsed.error).toContain("--service");
+    expect(parsed.error).toContain("--field");
+  });
+
   // -------------------------------------------------------------------------
   // Orchestrator error propagation
   // -------------------------------------------------------------------------

package/src/cli/commands/oauth/connect.ts

@@ -336,6 +336,17 @@ Examples:
             // BYO PATH
             // =============================================================
 
+            // Manual-token providers (slack_channel, telegram) don't use
+            // OAuth2 browser flows — credentials are configured via
+            // `assistant credentials` or chat setup instead.
+            if (providerRow.authUrl === "urn:manual-token") {
+              writeError(
+                `"${provider}" uses manual token configuration, not an OAuth browser flow. ` +
+                  `Set the token with: assistant credentials set <token_value> --service ${provider} --field <field_name>`,
+              );
+              return;
+            }
+
             // a. Resolve client credentials from the DB
             const dbApp = opts.clientId
               ? getAppByProviderAndClientId(provider, opts.clientId)

package/src/cli/commands/platform/__tests__/connect.test.ts

@@ -109,7 +109,7 @@ async function runCommand(
   process.exitCode = 0;
 
   try {
-    const program = buildCliProgram();
+    const program = await buildCliProgram();
     program.exitOverride();
     program.configureOutput({
       writeErr: () => {},

package/src/cli/commands/platform/__tests__/disconnect.test.ts

@@ -130,7 +130,7 @@ async function runCommand(
   process.exitCode = 0;
 
   try {
-    const program = buildCliProgram();
+    const program = await buildCliProgram();
     program.exitOverride();
     program.configureOutput({
       writeErr: () => {},

package/src/cli/commands/platform/__tests__/status.test.ts

@@ -110,7 +110,7 @@ async function runCommand(
   process.exitCode = 0;
 
   try {
-    const program = buildCliProgram();
+    const program = await buildCliProgram();
     program.exitOverride();
     program.configureOutput({
       writeErr: () => {},

package/src/cli/program.ts

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 
+import { initFeatureFlagOverrides } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
 import { isEmailEnabled } from "../email/feature-gate.js";
 import { registerHooksCommand } from "../hooks/cli.js";
@@ -33,13 +34,19 @@ import { registerSkillsCommand } from "./commands/skills.js";
 import { registerTrustCommand } from "./commands/trust.js";
 import { registerUsageCommand } from "./commands/usage.js";
 
-export function buildCliProgram(): Command {
+/**
+ * Build the CLI program tree. Pre-populates the feature flag cache from
+ * the gateway so flag-gated commands are registered correctly.
+ */
+export async function buildCliProgram(): Promise<Command> {
+  await initFeatureFlagOverrides();
   const program = new Command();
 
   program
     .name("assistant")
     .description("Local AI assistant")
-    .version(APP_VERSION);
+    .version(APP_VERSION)
+    .allowExcessArguments(true);
 
   program.addHelpText(
     "after",