@vellumai/assistant 0.8.6 → 0.8.7

package/src/calls/voice-session-bridge.ts

@@ -516,13 +516,9 @@ export async function startVoiceTurn(
               },
               "Consumed scoped grant — allowing non-guardian voice confirmation",
             );
-            conversation.handleConfirmationResponse(
-              msg.requestId,
-              "allow",
-              undefined,
-              undefined,
-              `Permission approved for "${msg.toolName}": guardian pre-approved via scoped grant.`,
-            );
+            conversation.handleConfirmationResponse(msg.requestId, "allow", {
+              decisionContext: `Permission approved for "${msg.toolName}": guardian pre-approved via scoped grant.`,
+            });
             broadcastMessage(msg);
             return;
           }
@@ -537,13 +533,9 @@ export async function startVoiceTurn(
           { turnId, toolName: msg.toolName },
           "Auto-denying confirmation request for non-guardian voice turn (no matching scoped grant)",
         );
-        conversation.handleConfirmationResponse(
-          msg.requestId,
-          "deny",
-          undefined,
-          undefined,
-          `Permission denied for "${msg.toolName}": this voice call does not have interactive approval capabilities. Side-effect tools are not available for non-guardian voice callers. In your next assistant reply, explain briefly that this action requires guardian-level access and cannot be performed during this call.`,
-        );
+        conversation.handleConfirmationResponse(msg.requestId, "deny", {
+          decisionContext: `Permission denied for "${msg.toolName}": this voice call does not have interactive approval capabilities. Side-effect tools are not available for non-guardian voice callers. In your next assistant reply, explain briefly that this action requires guardian-level access and cannot be performed during this call.`,
+        });
         broadcastMessage(msg);
         return;
       }
@@ -552,13 +544,9 @@ export async function startVoiceTurn(
           { turnId, toolName: msg.toolName },
           "Auto-approving confirmation request for guardian voice turn",
         );
-        conversation.handleConfirmationResponse(
-          msg.requestId,
-          "allow",
-          undefined,
-          undefined,
-          `Permission approved for "${msg.toolName}": this is a verified guardian voice call.`,
-        );
+        conversation.handleConfirmationResponse(msg.requestId, "allow", {
+          decisionContext: `Permission approved for "${msg.toolName}": this is a verified guardian voice call.`,
+        });
         broadcastMessage(msg);
         return;
       }
@@ -594,10 +582,8 @@ export async function startVoiceTurn(
       // flag into subsequent non-voice turns on the same conversation.
       conversation.forcePromptSideEffects =
         !isGuardian && !usesLocalInteractiveApprovals;
-      await conversation.runAgentLoop(
-        persistedContent,
-        messageId,
-        (msg: ServerMessage) => {
+      await conversation.runAgentLoop(persistedContent, messageId, {
+        onEvent: (msg: ServerMessage) => {
           if (msg.type === "error") {
             lastError = msg.message;
           } else if (msg.type === "conversation_error") {
@@ -624,8 +610,8 @@ export async function startVoiceTurn(
           // Note: tool_use_preview_start is intentionally not handled here.
           // Voice only reacts to the definitive tool_use_start event.
         },
-        { callSite: "callAgent" },
-      );
+        callSite: "callAgent",
+      });
       if (lastError) {
         log.error(
           { turnId, error: lastError },

package/src/cli/commands/__tests__/memory-v3.test.ts

@@ -0,0 +1,245 @@
+/**
+ * Tests for the `memory v3` CLI command group's daemon-side handlers.
+ *
+ * The CLI subcommands are thin IPC shells over the handlers in
+ * `runtime/routes/memory-v3-routes.ts`; the logic worth testing lives there.
+ * We exercise the handlers directly against a temp workspace + data dir
+ * injected via their `deps` parameter. Generic taxonomy only
+ * (domain-a/topic-x, etc.).
+ *
+ * Source-of-truth note: `health` and `set-core` build the leaf tree from each
+ * concept page's `leaves:` frontmatter (via the page index) and union it over
+ * `assignments.json`, matching the consolidation-injected health block. The
+ * fixture below writes concept pages with `leaves:` frontmatter as the
+ * authoritative membership and keeps a *stale* `assignments.json` to prove the
+ * handlers read the frontmatter, not the stale assignments. The seeded
+ * skill/CLI-command catalogs are mocked empty so `allSlugs` (derived from the
+ * page index) is deterministic.
+ */
+
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+
+import * as cliCommandStore from "../../../memory/v2/cli-command-store.js";
+import { invalidatePageIndex } from "../../../memory/v2/page-index.js";
+import * as skillStore from "../../../memory/v2/skill-store.js";
+import {
+  handleMemoryV3Health,
+  handleMemoryV3Reconcile,
+  handleMemoryV3SetCore,
+  UnknownLeafError,
+} from "../../../runtime/routes/memory-v3-routes.js";
+
+// ---------------------------------------------------------------------------
+// Temp data-dir fixture
+// ---------------------------------------------------------------------------
+
+let workspaceDir: string;
+let dataDir: string;
+
+/** Write a leaf markdown file with the given frontmatter under leaves/. */
+async function writeLeaf(
+  relPath: string,
+  frontmatter: { path: string; in_core: boolean; id?: string },
+  body = "description",
+): Promise<void> {
+  const file = join(dataDir, "leaves", `${relPath}.md`);
+  await mkdir(join(file, ".."), { recursive: true });
+  const fm = [
+    "---",
+    `path: ${frontmatter.path}`,
+    `in_core: ${frontmatter.in_core}`,
+    ...(frontmatter.id ? [`id: ${frontmatter.id}`] : []),
+    "---",
+    body,
+    "",
+  ].join("\n");
+  await writeFile(file, fm);
+}
+
+/** Write a concept page with `leaves:` frontmatter under memory/concepts/. */
+async function writePage(slug: string, leaves: string[]): Promise<void> {
+  const file = join(workspaceDir, "memory", "concepts", `${slug}.md`);
+  await mkdir(join(file, ".."), { recursive: true });
+  const fm = [
+    "---",
+    `summary: ${slug} summary`,
+    "leaves:",
+    ...leaves.map((l) => `  - ${l}`),
+    "---",
+    `${slug} body`,
+    "",
+  ].join("\n");
+  await writeFile(file, fm);
+}
+
+beforeEach(async () => {
+  workspaceDir = await mkdtemp(join(tmpdir(), "mem-v3-cli-ws-"));
+  dataDir = join(workspaceDir, "memory", "v3", "data");
+  await mkdir(dataDir, { recursive: true });
+
+  // Keep the page index deterministic regardless of the on-disk seeded
+  // catalogs, and clear any module-cached index from a prior test.
+  spyOn(skillStore, "listSkillEntries").mockReturnValue([]);
+  spyOn(cliCommandStore, "listCliCommandEntries").mockReturnValue([]);
+  invalidatePageIndex();
+
+  // A small generic tree: two leaves under domain-a, one under domain-b.
+  await writeLeaf("domain-a/topic-x", {
+    path: "domain-a/topic-x",
+    in_core: true,
+    id: "leaf-x",
+  });
+  await writeLeaf("domain-a/topic-y", {
+    path: "domain-a/topic-y",
+    in_core: false,
+    id: "leaf-y",
+  });
+  await writeLeaf("domain-b/topic-z", {
+    path: "domain-b/topic-z",
+    in_core: false,
+    id: "leaf-z",
+  });
+
+  // Authoritative membership lives in each page's `leaves:` frontmatter.
+  await writePage("page-1", ["domain-a/topic-x"]);
+  await writePage("page-2", ["domain-a/topic-x", "domain-a/topic-y"]);
+  await writePage("page-3", ["domain-b/topic-z"]);
+
+  // STALE assignments.json: deliberately divergent from the frontmatter above.
+  // It re-maps the SAME slugs that already carry `leaves:` frontmatter to the
+  // WRONG leaves. `loadLeafTree`'s per-page precedence only lets frontmatter win
+  // when it is non-empty, so for these slugs the frontmatter wins and
+  // assignments.json contributes no membership — proving the handlers read the
+  // page index, not these stale assignments (the regression Defect A guards
+  // against). We deliberately avoid a slug that exists ONLY in assignments.json:
+  // such a slug has no frontmatter, falls back to its assignments entry, and
+  // would inflate the cost preview below with phantom membership.
+  await writeFile(
+    join(dataDir, "assignments.json"),
+    JSON.stringify({
+      "page-1": ["domain-a/bogus-leaf"],
+      "page-2": ["domain-b/topic-z"],
+    }),
+  );
+  await writeFile(
+    join(dataDir, "core.json"),
+    JSON.stringify({ alwaysOn: ["domain-a/topic-x"] }),
+  );
+});
+
+afterEach(async () => {
+  invalidatePageIndex();
+  await rm(workspaceDir, { recursive: true, force: true });
+});
+
+// ---------------------------------------------------------------------------
+// set-core
+// ---------------------------------------------------------------------------
+
+describe("handleMemoryV3SetCore", () => {
+  test("rejects an unknown leaf and does not write", async () => {
+    const call = handleMemoryV3SetCore(
+      { add: ["domain-a/does-not-exist"], write: true },
+      { dataDir, workspaceDir },
+    );
+    await expect(call).rejects.toThrow(/domain-a\/does-not-exist/);
+    await expect(
+      handleMemoryV3SetCore(
+        { add: ["domain-a/does-not-exist"], write: true },
+        { dataDir, workspaceDir },
+      ),
+    ).rejects.toBeInstanceOf(UnknownLeafError);
+
+    // core.json must be untouched (still just the original entry).
+    const core = JSON.parse(await readFile(join(dataDir, "core.json"), "utf8"));
+    expect(core.alwaysOn).toEqual(["domain-a/topic-x"]);
+  });
+
+  test("previews the always-on page count from frontmatter membership", async () => {
+    // Adding topic-y to core: core = {topic-x, topic-y}. Membership comes from
+    // page `leaves:` frontmatter — topic-x → {page-1, page-2}, topic-y →
+    // {page-2} ⇒ unique always-on slugs {page-1, page-2} = 2. If the handler
+    // read the stale assignments.json instead (page-1 → bogus-leaf, page-2 →
+    // topic-z), topic-x/topic-y would have no members and this would be 0.
+    const result = await handleMemoryV3SetCore(
+      { add: ["domain-a/topic-y"] },
+      { dataDir, workspaceDir },
+    );
+    expect(result.written).toBe(false);
+    expect(result.nextCore).toEqual(["domain-a/topic-x", "domain-a/topic-y"]);
+    expect(result.alwaysOnPageCount).toBe(2);
+
+    // No write happened — core.json still holds only the original entry.
+    const core = JSON.parse(await readFile(join(dataDir, "core.json"), "utf8"));
+    expect(core.alwaysOn).toEqual(["domain-a/topic-x"]);
+  });
+
+  test("writes core.json on --yes (write: true)", async () => {
+    const result = await handleMemoryV3SetCore(
+      { add: ["domain-b/topic-z"], write: true },
+      { dataDir, workspaceDir },
+    );
+    expect(result.written).toBe(true);
+    expect(result.nextCore).toEqual(["domain-a/topic-x", "domain-b/topic-z"]);
+
+    const core = JSON.parse(await readFile(join(dataDir, "core.json"), "utf8"));
+    expect(core.alwaysOn).toEqual(["domain-a/topic-x", "domain-b/topic-z"]);
+  });
+
+  test("remove is idempotent for an absent entry", async () => {
+    const result = await handleMemoryV3SetCore(
+      { remove: ["domain-a/topic-y"], write: true },
+      { dataDir, workspaceDir },
+    );
+    // topic-y was never in core; result is the original core unchanged.
+    expect(result.nextCore).toEqual(["domain-a/topic-x"]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// health
+// ---------------------------------------------------------------------------
+
+describe("handleMemoryV3Health", () => {
+  test("computes the slug universe from page frontmatter, not assignments.json", async () => {
+    const result = await handleMemoryV3Health({ dataDir, workspaceDir });
+    // domain-b/topic-z has a single member ⇒ a tiny leaf, so the report is
+    // non-empty and renders the memory-v3 health header.
+    expect(result.rendered).toContain("memory-v3 health:");
+    expect(result.counts.tinyLeaves).toBeGreaterThanOrEqual(1);
+    // Every page leaf ref (from frontmatter) resolves to a real leaf file ⇒ no
+    // dangling refs. If assignments.json were the source, page-1's bogus-leaf
+    // would dangle.
+    expect(result.counts.danglingRefs).toBe(0);
+    // The slug universe is the page-index pages (page-1..3), all assigned via
+    // frontmatter, so nothing is unassigned.
+    expect(result.counts.unassigned).toBe(0);
+  });
+
+  test("flags a page frontmatter ref with no backing leaf as dangling", async () => {
+    await writePage("page-4", ["domain-a/missing-leaf"]);
+    invalidatePageIndex();
+    const result = await handleMemoryV3Health({ dataDir, workspaceDir });
+    expect(result.counts.danglingRefs).toBeGreaterThanOrEqual(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// reconcile
+// ---------------------------------------------------------------------------
+
+describe("handleMemoryV3Reconcile", () => {
+  test("no-op reconcile against an unchanged tree returns empty diffs", async () => {
+    // v1: prevLeaves is derived from the current tree, so diffing
+    // current-vs-current yields no renames/deletes — reconcile runs as a
+    // convergence/prune pass. This still drives the full reconcileTree path
+    // (snapshot → apply → validate → invalidate).
+    const result = await handleMemoryV3Reconcile({ dataDir, workspaceDir });
+    expect(result.renames).toEqual([]);
+    expect(result.deleted).toEqual([]);
+    expect(result.prunedCore).toEqual([]);
+  });
+});

package/src/cli/commands/avatar.ts

@@ -84,7 +84,9 @@ Examples:
 
       avatar
         .command("set")
-        .description("Set the assistant's avatar from an image file")
+        .description(
+          "Set the assistant's avatar from an image file (removes any native character)",
+        )
         .requiredOption(
           "--image <path>",
           "Path to image file (absolute or relative to workspace)",
@@ -93,9 +95,11 @@ Examples:
           "after",
           `
 Sets the assistant's avatar by copying the provided image file to the
-canonical avatar location. This replaces any existing avatar image but
-preserves character-traits.json so the native character can be restored
-later with "assistant avatar remove".
+canonical avatar location. This REPLACES any existing avatar and removes
+any configured native character: character-traits.json (and character-ascii.txt)
+are deleted, so a previously configured character is NOT preserved and cannot
+be restored. Rebuild the character with "assistant avatar character update"
+to reconfigure one.
 
 The --image path can be absolute or relative to the workspace directory.
 
@@ -131,16 +135,18 @@ Examples:
 
       avatar
         .command("remove")
-        .description("Remove custom avatar and restore character default")
+        .description("Reset the avatar to none (clears image and character)")
         .addHelpText(
           "after",
           `
-Removes the custom avatar image. If a native character was previously
-configured (character-traits.json still exists), it will be automatically
-restored the next time the avatar is regenerated.
-
-Does not delete character-traits.json — the native character is preserved
-so it can be restored without reconfiguration.
+Resets the avatar to its empty state. This deletes ALL avatar artifacts —
+the custom image (avatar-image.png) AND any configured native character
+(character-traits.json / character-ascii.txt) — and marks the avatar as
+"none".
+
+This is destructive: a previously configured native character is NOT
+preserved and will not be restored. Rebuild the character (or set a new
+image) to configure an avatar again.
 
 Examples:
   $ assistant avatar remove`,

package/src/cli/commands/conversations.ts

@@ -162,6 +162,10 @@ Examples:
           `
 Shows conversations with their ID, title, and a relative timestamp (e.g.
 "3 hours ago"). Conversations are listed in order of most recently updated.
+Rows currently mid-turn — i.e. the agent loop is actively running on the
+in-memory conversation — are prefixed with "●"; idle rows are prefixed
+with " " (two spaces) so columns stay aligned.
+
 Archived conversations are excluded by default; pass --include-archived to
 include them.
 
@@ -175,6 +179,7 @@ Examples:
               id: string;
               title: string | null;
               updatedAt: number;
+              isProcessing: boolean;
             }>;
           }>("conversation_list_cli", {
             body: { includeArchived: opts?.includeArchived ?? false },
@@ -187,8 +192,12 @@ Examples:
             log.info("No conversations");
           } else {
             for (const s of all) {
+              // "●" marks a conversation whose agent loop is mid-turn;
+              // a single space keeps idle rows aligned without padding
+              // every line with the marker glyph.
+              const marker = s.isProcessing ? "●" : " ";
               log.info(
-                `  ${s.id}  ${s.title ?? "Untitled"}  ${timeAgo(s.updatedAt)}`,
+                `  ${marker} ${s.id}  ${s.title ?? "Untitled"}  ${timeAgo(s.updatedAt)}`,
               );
             }
           }
@@ -488,6 +497,11 @@ Examples:
 
           const result = await cliIpcCall<{ cleared: number }>(
             "conversations_clear_cli",
+            {
+              headers: {
+                "x-confirm-destructive": "clear-all-conversations",
+              },
+            },
           );
 
           if (!result.ok) return exitFromIpcResult(result);