@vellumai/assistant 0.8.4 → 0.8.5

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

@@ -0,0 +1,316 @@
+/**
+ * `assistant memory v3` CLI subgroup.
+ *
+ * Operator-facing read-only inspection of the v3 memory tree — the DAG overlay
+ * the v2 → v3 data-migration hand-authors over the flat concept pages.
+ *
+ * Subcommands:
+ *
+ *   - `validate` — print a structural health report (dangling refs, orphan
+ *     pages, cycles, stale indexes, unknown edge targets). Exits non-zero when
+ *     any defect is found so it is scriptable as a check.
+ *   - `tree` — print the tree as an indented outline rooted at the tree root,
+ *     marking shared-DAG re-entries.
+ *   - `simulate` — dry-run the v3 retrieval loop against an ad-hoc query and
+ *     print the per-pass descent trace plus the lane-grouped selection.
+ *
+ * All are read-only: they mutate nothing. `validate`/`tree` run no LLM;
+ * `simulate` invokes the loop (filter + gate LLM calls) but persists nothing.
+ * `--json` emits the raw daemon payload for any subcommand.
+ */
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { Command } from "commander";
+
+import { cliIpcCall } from "../../ipc/cli-client.js";
+import type {
+  MemoryV3SimulateResult,
+  MemoryV3TreeResult,
+  MemoryV3ValidateResult,
+} from "../../runtime/routes/memory-v3-routes.js";
+import { registerCommand } from "../lib/register-command.js";
+import { log } from "../logger.js";
+import {
+  renderLlmCalls,
+  renderSimulation,
+  renderTree,
+  renderValidationReport,
+  reportHasDefects,
+} from "./memory-v3-render.js";
+
+/** Valid lane names accepted by `--lanes` (matches memory.v3.lanes keys). */
+const V3_LANE_NAMES = ["hot", "sparse", "dense", "tree", "edges"] as const;
+
+export function registerMemoryV3Command(program: Command): void {
+  // Reuse an existing `memory` parent if a sibling registrar (e.g. v2)
+  // attached it first; otherwise create one. Keeps registration order between
+  // sibling memory registrars unconstrained.
+  const memory =
+    program.commands.find((c) => c.name() === "memory") ??
+    program
+      .command("memory")
+      .description("Manage the memory subsystem (concept-page model)");
+
+  registerCommand(memory, {
+    name: "v3",
+    transport: "ipc",
+    description: "Memory v3 subsystem operations (tree-DAG overlay)",
+    build: (v3) => {
+      v3.addHelpText(
+        "after",
+        `
+The v3 memory subsystem layers a hand-authored DAG of tree nodes over the
+flat v2 concept pages. Each node lives under /workspace/memory/tree/ and
+its frontmatter 'children' list references sub-nodes (node:<id>) and leaf
+concept pages (page:<slug>). The structure is authored by the v2 → v3
+data-migration, so these subcommands are read-only inspection only — they
+mutate nothing and run no LLM.
+
+Examples:
+  $ assistant memory v3 validate
+  $ assistant memory v3 tree
+  $ assistant memory v3 tree --json | jq '.nodes | length'
+  $ assistant memory v3 simulate -q "what should we ship next"`,
+      );
+
+      // ── validate ──────────────────────────────────────────────────────────
+
+      v3.command("validate")
+        .description(
+          "Print a structural health report of the v3 tree (read-only)",
+        )
+        .option("--json", "Emit raw JSON instead of a formatted report")
+        .addHelpText(
+          "after",
+          `
+Walks the hand-authored v3 tree DAG and reports:
+  - Dangling child refs (node:/page: targets that do not exist)
+  - Orphan pages (concept pages not reachable from the tree root)
+  - Cycles (back-edges in the node:/node: adjacency)
+  - Stale indexes (a node older than a child it composes)
+  - Unknown edge targets (page edges: pointing at a missing slug)
+
+Read-only — mutates nothing. Exits non-zero if any defect is reported, so it
+is usable as a pre-flight check while the v2 → v3 migration is in flight.
+
+Examples:
+  $ assistant memory v3 validate
+  $ assistant memory v3 validate --json | jq '.orphanPageCount'`,
+        )
+        .action(async (opts: { json?: boolean }) => {
+          const result = await cliIpcCall<MemoryV3ValidateResult>(
+            "memory_v3_validate",
+            { body: {} },
+          );
+
+          if (!result.ok) {
+            log.error(result.error ?? "Failed to validate memory v3 tree");
+            process.exitCode = 1;
+            return;
+          }
+
+          const report = result.result!;
+
+          if (opts.json === true) {
+            log.info(JSON.stringify(report, null, 2));
+          } else {
+            log.info(renderValidationReport(report));
+          }
+
+          if (reportHasDefects(report)) {
+            process.exitCode = 1;
+          }
+        });
+
+      // ── tree ──────────────────────────────────────────────────────────────
+
+      v3.command("tree")
+        .description(
+          "Print the v3 tree as an indented outline from the root (read-only)",
+        )
+        .option("--json", "Emit raw JSON instead of a formatted tree")
+        .addHelpText(
+          "after",
+          `
+Descends the v3 tree depth-first from its root node, printing one line per
+node:/page: ref with indentation by depth. A node reached more than once
+(shared DAG sub-node or a cycle back-edge) is printed once with a re-entry
+marker rather than re-expanded, so output is finite. Nodes that exist on disk
+but are unreachable from the root are listed separately.
+
+Read-only — mutates nothing.
+
+Examples:
+  $ assistant memory v3 tree
+  $ assistant memory v3 tree --json | jq '.root'`,
+        )
+        .action(async (opts: { json?: boolean }) => {
+          const result = await cliIpcCall<MemoryV3TreeResult>(
+            "memory_v3_tree",
+            {
+              body: {},
+            },
+          );
+
+          if (!result.ok) {
+            log.error(result.error ?? "Failed to read memory v3 tree");
+            process.exitCode = 1;
+            return;
+          }
+
+          const view = result.result!;
+
+          if (opts.json === true) {
+            log.info(JSON.stringify(view, null, 2));
+            return;
+          }
+
+          log.info(renderTree(view));
+        });
+
+      // ── simulate ────────────────────────────────────────────────────────────
+
+      v3.command("simulate")
+        .description(
+          "Dry-run the v3 retrieval loop against an ad-hoc query (read-only)",
+        )
+        .requiredOption(
+          "-q, --query <text>",
+          "User query to run a single synthetic retrieval turn against",
+        )
+        .option(
+          "--pass-cap <n>",
+          "Override memory.v3.passCap for this run (positive integer)",
+        )
+        .option(
+          "--lanes <list>",
+          `Restrict to a comma-separated allowlist of lanes (others off): ${V3_LANE_NAMES.join(", ")}`,
+        )
+        .option("--json", "Emit raw JSON instead of a formatted report")
+        .option(
+          "--show-llm",
+          "Print the full input + output of every v3 LLM call (filter / descender / gate)",
+        )
+        .option(
+          "--dump-llm <dir>",
+          "Write one JSON file per v3 LLM call into <dir> (full request + raw response)",
+        )
+        .addHelpText(
+          "after",
+          `
+Runs the v3 multi-lane bounded-descent loop read-only against the live page
+index + tree DAG, building a single synthetic turn from the query plus the live
+NOW context. Prints the per-pass descent trace (scouts / tree levels / edge
+expansions / gate verdict) and the final selection grouped by provenance lane.
+
+The loop is invoked directly — it does NOT require memory.v3.enabled or
+memory.v3.shadow, so you can probe v3 retrieval before the flags flip. Writes
+nothing (co-activation persistence is forced off), but each pass still spends
+the loop's dense-filter + gate LLM calls, so pass-cap is the cost knob.
+
+Examples:
+  $ assistant memory v3 simulate -q "what should we ship next"
+  $ assistant memory v3 simulate -q "..." --lanes tree,edges
+  $ assistant memory v3 simulate -q "..." --pass-cap 1 --json | jq '.selectedSlugs'
+  $ assistant memory v3 simulate -q "..." --show-llm
+  $ assistant memory v3 simulate -q "..." --dump-llm /tmp/v3-calls`,
+        )
+        .action(
+          async (opts: {
+            query: string;
+            passCap?: string;
+            lanes?: string;
+            json?: boolean;
+            showLlm?: boolean;
+            dumpLlm?: string;
+          }) => {
+            let passCap: number | undefined;
+            if (opts.passCap !== undefined) {
+              const parsed = Number(opts.passCap);
+              if (!Number.isInteger(parsed) || parsed < 1) {
+                log.error(
+                  `--pass-cap must be a positive integer (got "${opts.passCap}")`,
+                );
+                process.exitCode = 1;
+                return;
+              }
+              passCap = parsed;
+            }
+
+            let lanes: string[] | undefined;
+            if (opts.lanes !== undefined) {
+              const requested = opts.lanes
+                .split(",")
+                .map((s) => s.trim())
+                .filter((s) => s.length > 0);
+              const invalid = requested.filter(
+                (l) =>
+                  !V3_LANE_NAMES.includes(l as (typeof V3_LANE_NAMES)[number]),
+              );
+              if (invalid.length > 0) {
+                log.error(
+                  `--lanes contains unknown lane(s): ${invalid.join(", ")}. Valid: ${V3_LANE_NAMES.join(", ")}`,
+                );
+                process.exitCode = 1;
+                return;
+              }
+              if (requested.length === 0) {
+                log.error("--lanes must list at least one lane");
+                process.exitCode = 1;
+                return;
+              }
+              lanes = requested;
+            }
+
+            const result = await cliIpcCall<MemoryV3SimulateResult>(
+              "memory_v3_simulate",
+              {
+                body: {
+                  query: opts.query,
+                  ...(passCap !== undefined ? { passCap } : {}),
+                  ...(lanes !== undefined ? { lanes } : {}),
+                },
+              },
+            );
+
+            if (!result.ok) {
+              log.error(result.error ?? "Failed to simulate v3 retrieval");
+              process.exitCode = 1;
+              return;
+            }
+
+            const payload = result.result!;
+            if (opts.json === true) {
+              log.info(JSON.stringify(payload, null, 2));
+              return;
+            }
+            log.info(renderSimulation(payload));
+
+            log.info("");
+            log.info(
+              renderLlmCalls(payload.llmCalls, { full: opts.showLlm === true }),
+            );
+
+            if (opts.dumpLlm !== undefined) {
+              mkdirSync(opts.dumpLlm, { recursive: true });
+              for (const call of payload.llmCalls) {
+                const nodePart = call.node
+                  ? `-${call.node.replace(/\//g, "_")}`
+                  : "";
+                const file = join(
+                  opts.dumpLlm,
+                  `pass${call.pass}-${call.lane}${nodePart}.json`,
+                );
+                writeFileSync(file, JSON.stringify(call, null, 2));
+              }
+              log.info(
+                `\nWrote ${payload.llmCalls.length} LLM-call file(s) to ${opts.dumpLlm}`,
+              );
+            }
+          },
+        );
+    },
+  });
+}

package/src/cli/program.ts

@@ -34,6 +34,7 @@ import { registerInferenceCommand } from "./commands/inference.js";
 import { registerKeysCommand } from "./commands/keys.js";
 import { registerMcpCommand } from "./commands/mcp.js";
 import { registerMemoryV2Command } from "./commands/memory-v2.js";
+import { registerMemoryV3Command } from "./commands/memory-v3.js";
 import { registerNotificationsCommand } from "./commands/notifications.js";
 import { registerOAuthCommand } from "./commands/oauth/index.js";
 import { registerPendingCommand } from "./commands/pending.js";
@@ -129,6 +130,7 @@ Examples:
   registerKeysCommand(program);
   registerMcpCommand(program);
   registerMemoryV2Command(program);
+  registerMemoryV3Command(program);
   registerNotificationsCommand(program);
   registerOAuthCommand(program);
   registerPendingCommand(program);

package/src/config/assistant-feature-flags.ts

@@ -7,7 +7,7 @@
  * (in priority order):
  *   1. Override values from the gateway IPC socket
  *   2. defaults registry `defaultEnabled`         (for declared keys)
- *   3. `true`                                     (for undeclared keys)
+ *   3. `false`                                    (for undeclared keys)
  *
  * Key format:
  *   Canonical:  simple kebab-case string (e.g., "browser", "ces-tools")
@@ -172,8 +172,8 @@ const DEFAULT_INIT_RETRY_BACKOFFS_MS: readonly number[] = [
  * Retries the gateway IPC fetch on empty/failed results — the gateway
  * may not have bound its IPC socket yet when the daemon races ahead at
  * startup. After exhausting retries, the cache is left unset so
- * subsequent sync calls return an empty override map (registry defaults
- * only).
+ * subsequent sync calls return an empty override map (registry defaults for
+ * declared flags, fail-closed for undeclared flags).
  *
  * Pass `retryBackoffsMs: []` to disable retries (used by unit tests that
  * intentionally simulate an unreachable gateway and want immediate
@@ -229,12 +229,11 @@ export async function initFeatureFlagOverrides(options?: {
 
   // Exhausted retries — leave cache unset so loadOverrides() returns an
   // empty map on subsequent sync reads. Flag checks fall through to the
-  // registry default (`defaultEnabled`), which biases toward off for
-  // newer assistant-scope flags.
+  // registry default (`defaultEnabled`) or the fail-closed undeclared default.
   if (backoffs.length > 0) {
     log.warn(
       { attempts: backoffs.length + 1 },
-      "Feature flag overrides empty after all retries; falling back to registry defaults",
+      "Feature flag overrides empty after all retries; falling back to registry defaults and fail-closed undeclared flags",
     );
   }
 }
@@ -260,6 +259,19 @@ export function clearFeatureFlagOverridesCache(): void {
   cachedOverridesFromGateway = false;
 }
 
+/**
+ * Re-fetch feature flag overrides from the gateway.
+ *
+ * Clears the cached overrides and re-runs the gateway IPC fetch without
+ * retries (the gateway is known to be up because it just pushed an event).
+ * Called by the gateway flag listener when a `feature_flags_changed` event
+ * arrives.
+ */
+export async function refreshOverridesFromGateway(): Promise<void> {
+  clearFeatureFlagOverridesCache();
+  await initFeatureFlagOverrides({ retryBackoffsMs: [] });
+}
+
 /**
  * Directly inject override values into the module-level cache.
  *
@@ -287,7 +299,7 @@ export function _setOverridesForTesting(
  *      values, which the gateway merges server-side: persisted > remote >
  *      registry)
  *   2. Registry `defaultEnabled` (for declared assistant-scope keys)
- *   3. `true` (for undeclared keys with no override)
+ *   3. `false` (for undeclared keys with no override)
  */
 export function isAssistantFeatureFlagEnabled(
   key: string,
@@ -304,6 +316,6 @@ export function isAssistantFeatureFlagEnabled(
   // 2. For declared keys, use the registry default.
   if (declared) return declared.defaultEnabled;
 
-  // 3. Undeclared keys with no override default to enabled.
-  return true;
+  // 3. Undeclared keys with no override fail closed.
+  return false;
 }

package/src/config/bundled-skills/document-editor/SKILL.md

@@ -16,6 +16,7 @@ Create and edit long-form documents using the built-in rich text editor. Documen
 
 ## Tools
 
+- **document_open** - Opens an existing document in the editor panel by `surface_id`. Use this when a document exists but isn't visible in the editor — for example after the user switches devices, refreshes the page, or when the editor panel was closed. Fetches the document from storage and sends it to the client.
 - **document_create** - Opens a new document editor with an optional title and initial Markdown content. Returns a `surface_id` for subsequent updates.
 - **document_update** - Updates content in an open document editor by `surface_id`. Supports `replace` (overwrite) and `append` (add to end) modes.
 - **document_read** - Reads the current content of a document by `surface_id` when it belongs to the current conversation, or when the current actor is the guardian/local user. Use to verify content before editing.
@@ -28,12 +29,14 @@ Create and edit long-form documents using the built-in rich text editor. Documen
 
 When the user asks to see, open, or pull up a document:
 
-1. Check the `<active_documents>` block in your context — it lists all documents in this conversation with their `surface_id` and title. If the document is there, call `document_read` with its `surface_id`. Done in one call.
+1. Check the `<active_documents>` block in your context — it lists all documents in this conversation with their `surface_id` and title.
 2. If the document is NOT in `<active_documents>`, call `document_list` with a `query` matching the document title. For guardian/local users, this searches across previous conversations and sessions.
-3. Once you have the `surface_id`, call `document_read` to retrieve the content.
+3. Once you have the `surface_id`, call `document_open` to open the editor panel. This both surfaces the editor on the client and returns the document content. If the user only needs the text (not the editor), use `document_read` instead.
 
 **Never** search the filesystem, conversation history, or archives to find a document. Always use `document_list` with a `query`.
 
+**If the user says they can't see a document you know exists** (e.g. after switching from macOS to web, or after a page refresh), call `document_open` with the `surface_id` to re-surface the editor panel on their current client.
+
 ## Creating a new document
 
 1. **Create the document**: Call `document_create` with a title (inferred from the request). Call the tool immediately, not after conversational preamble.
@@ -107,6 +110,12 @@ Users can leave inline comments on documents. Open comments are surfaced in a `<
 3. Call `comment_resolve` on comments you have addressed.
 4. If a comment is ambiguous, call `comment_reply` to ask for clarification instead of guessing.
 
+## Anti-Patterns
+
+- **Don't use `app_create` for blog posts, articles, or written content.** Use `document_create` — apps are for interactive content with state/data.
+- **Don't output the full content in chat.** The content goes in the document editor, not in the chat response. Acknowledge what you're doing and stream to the editor.
+- **Don't wait to generate everything before sending.** Stream content in chunks via `document_update` with `mode: "append"` so users see progress in real time.
+
 ## Usage Notes
 
 - The `mode` parameter on `document_update` defaults to `append`.

package/src/config/bundled-skills/document-editor/TOOLS.json

@@ -1,6 +1,24 @@
 {
   "version": 1,
   "tools": [
+    {
+      "name": "document_open",
+      "description": "Open an existing document in the editor panel. Use this when the user asks to see or pull up a document that exists but isn't currently visible in the editor — for example after switching devices, refreshing, or when the editor panel was closed.",
+      "category": "document-editor",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "surface_id": {
+            "type": "string",
+            "description": "The ID of the document to open"
+          }
+        },
+        "required": ["surface_id"]
+      },
+      "executor": "tools/document-open.ts",
+      "execution_target": "host"
+    },
     {
       "name": "document_create",
       "description": "Create a new long-form document with a rich text editor. Use this when the user asks to write a blog post, article, or any long-form content. The editor opens in workspace mode with chat docked to the side.",

package/src/config/bundled-skills/document-editor/tools/document-open.ts

@@ -0,0 +1,12 @@
+import { executeDocumentOpen } from "../../../../tools/document/document-tool.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+
+export async function run(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  return executeDocumentOpen(input, context);
+}

package/src/config/bundled-skills/image-studio/SKILL.md

@@ -37,3 +37,7 @@ You are an image generation assistant. When the user asks you to create or edit
 - When editing images, clearly describe what changes you want made to the source image.
 - Use the `variants` parameter (1-4) to generate multiple options and pick the best one.
 - If no API key is configured for the selected model's provider (Gemini or OpenAI), the tool will return an error - ask the user to set one up.
+
+## Error handling
+
+When image generation fails, report the error to the user as-is. **Do not** attempt to fix the error by changing service configuration (e.g. switching between "managed" and "your-own" mode, or changing the provider/model). Service configuration changes should only be made at the user's explicit request via Settings.

package/src/config/bundled-skills/image-studio/tools/media-generate-image.ts

@@ -30,7 +30,7 @@ export async function run(
   });
   if (!credentials) {
     return {
-      content: errorHint ?? "Image generation is not configured.",
+      content: `${errorHint ?? "Image generation is not configured."}\n\nReport this error to the user. Do not change service configuration (mode, provider, or model) to try to fix it.`,
       isError: true,
     };
   }
@@ -131,7 +131,7 @@ export async function run(
     };
   } catch (error) {
     return {
-      content: mapImageGenError(provider, error),
+      content: `${mapImageGenError(provider, error)}\n\nReport this error to the user. Do not change service configuration (mode, provider, or model) to try to fix it.`,
       isError: true,
     };
   }

package/src/config/bundled-skills/media-processing/tools/ingest-media.ts

@@ -1,7 +1,10 @@
 import { access } from "node:fs/promises";
 import { basename, extname } from "node:path";
 
-import { enqueueMemoryJob } from "../../../../memory/jobs-store.js";
+import {
+  enqueueMemoryJob,
+  isMemoryEnabled,
+} from "../../../../memory/jobs-store.js";
 import {
   computeFileHashStreaming,
   createProcessingStage,
@@ -199,13 +202,15 @@ export async function run(
   updateMediaAssetStatus(asset.id, "processing");
 
   // Enqueue a processing job via the existing jobs framework
-  enqueueMemoryJob("media_processing", {
-    mediaAssetId: asset.id,
-    stage: "ingest",
-    filePath,
-    mimeType,
-    mediaType,
-  });
+  if (isMemoryEnabled()) {
+    enqueueMemoryJob("media_processing", {
+      mediaAssetId: asset.id,
+      stage: "ingest",
+      filePath,
+      mimeType,
+      mediaType,
+    });
+  }
 
   context.onOutput?.(`Registered media asset: ${asset.id}\n`);
 

package/src/config/bundled-skills/messaging/tools/messaging-analyze-style.ts

@@ -2,7 +2,10 @@ import { and, eq, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "../../../../memory/db-connection.js";
-import { enqueueMemoryJob } from "../../../../memory/jobs-store.js";
+import {
+  enqueueMemoryJob,
+  isMemoryEnabled,
+} from "../../../../memory/jobs-store.js";
 import { memoryGraphNodes } from "../../../../memory/schema.js";
 import { clampUnitInterval } from "../../../../memory/validation.js";
 import { extractStylePatterns } from "../../../../messaging/style-analyzer.js";
@@ -56,7 +59,9 @@ function upsertMemoryItem(opts: {
       })
       .where(eq(memoryGraphNodes.id, existing.id))
       .run();
-    enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
+    if (isMemoryEnabled()) {
+      enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
+    }
   } else {
     const id = uuid();
     db.insert(memoryGraphNodes)
@@ -82,7 +87,9 @@ function upsertMemoryItem(opts: {
         scopeId: opts.scopeId,
       })
       .run();
-    enqueueMemoryJob("embed_graph_node", { nodeId: id });
+    if (isMemoryEnabled()) {
+      enqueueMemoryJob("embed_graph_node", { nodeId: id });
+    }
   }
 }
 

package/src/config/bundled-skills/phone-calls/references/TRANSCRIPTS.md

@@ -1,13 +1,15 @@
 # Retrieving Past Call Transcripts
 
-After a call ends, the full bidirectional transcript (caller speech, assistant responses, tool calls, and tool results) is stored in the SQLite database. The daemon logs (`vellum.log`) only contain caller-side transcripts and lifecycle events at the default log level, so they are **not sufficient** for full transcript reconstruction.
+After a call ends, the full bidirectional transcript (caller speech, assistant responses, tool calls, and tool results) is stored in the SQLite database. The assistant logs only contain caller-side transcripts and lifecycle events at the default log level, so they are **not sufficient** for full transcript reconstruction.
+
+Logs rotate daily as `$VELLUM_WORKSPACE_DIR/data/logs/assistant-YYYY-MM-DD.log`. The commands below use today's UTC log file; if a call happened on a previous day, swap the date in or grep across `assistant-*.log`.
 
 ## Finding the conversation
 
-1. **Get the call session ID and voice conversation ID** from `vellum.log` by searching for recent session creation entries:
+1. **Get the call session ID and voice conversation ID** from today's log by searching for recent session creation entries:
 
 ```bash
-grep "voiceConversationId" ~/.vellum/workspace/data/logs/vellum.log | tail -5
+grep "voiceConversationId" "$VELLUM_WORKSPACE_DIR/data/logs/assistant-$(date -u +%Y-%m-%d).log" | tail -5
 ```
 
 The `voiceConversationId` field in the `Created new inbound voice session` (or outbound equivalent) log line is the key you need.
@@ -15,7 +17,7 @@ The `voiceConversationId` field in the `Created new inbound voice session` (or o
 2. **Query the messages table** in the SQLite database using the voice conversation ID:
 
 ```bash
-sqlite3 ~/.vellum/workspace/data/db/assistant.db \
+sqlite3 "$VELLUM_WORKSPACE_DIR/data/db/assistant.db" \
   "SELECT role, content FROM messages WHERE conversation_id = '<voiceConversationId>' ORDER BY created_at ASC;"
 ```
 
@@ -27,9 +29,9 @@ This returns all messages in chronological order with:
 ## Quick one-liner for the most recent call
 
 ```bash
-CONV_ID=$(grep "voiceConversationId" ~/.vellum/workspace/data/logs/vellum.log | tail -1 | python3 -c "import sys,json; print(json.loads(sys.stdin.readline().strip())['voiceConversationId'])")
+CONV_ID=$(grep -h "voiceConversationId" "$VELLUM_WORKSPACE_DIR"/data/logs/assistant-*.log | tail -1 | python3 -c "import sys,json; print(json.loads(sys.stdin.readline().strip())['voiceConversationId'])")
 
-sqlite3 ~/.vellum/workspace/data/db/assistant.db \
+sqlite3 "$VELLUM_WORKSPACE_DIR/data/db/assistant.db" \
   "SELECT role, content FROM messages WHERE conversation_id = '$CONV_ID' ORDER BY created_at ASC;"
 ```
 
@@ -44,14 +46,14 @@ sqlite3 ~/.vellum/workspace/data/db/assistant.db \
 
 ## Key paths
 
-| Resource                                      | Path                                       |
-| --------------------------------------------- | ------------------------------------------ |
-| Assistant logs (caller-side transcripts only) | `~/.vellum/workspace/data/logs/vellum.log` |
-| Full conversation database                    | `~/.vellum/workspace/data/db/assistant.db` |
-| Messages table                                | `messages` (keyed by `conversation_id`)    |
-| Call sessions table                           | `call_sessions`                            |
-| Call events table                             | `call_events`                              |
+| Resource                                      | Path                                                  |
+| --------------------------------------------- | ----------------------------------------------------- |
+| Assistant logs (caller-side transcripts only) | `$VELLUM_WORKSPACE_DIR/data/logs/assistant-*.log`     |
+| Full conversation database                    | `$VELLUM_WORKSPACE_DIR/data/db/assistant.db`          |
+| Messages table                                | `messages` (keyed by `conversation_id`)               |
+| Call sessions table                           | `call_sessions`                                       |
+| Call events table                             | `call_events`                                         |
 
 ## Important
 
-`vellum.log` at the default log level does **not** contain assistant responses, TTS text, or LLM completions for voice calls. Always use the `messages` table in `assistant.db` as the source of truth for complete call transcripts.
+Assistant log files at the default log level do **not** contain assistant responses, TTS text, or LLM completions for voice calls. Always use the `messages` table in `assistant.db` as the source of truth for complete call transcripts.

package/src/config/bundled-skills/playbooks/tools/playbook-create.ts

@@ -3,7 +3,10 @@ import { sql } from "drizzle-orm";
 import { getDb } from "../../../../memory/db-connection.js";
 import { createNode, updateNode } from "../../../../memory/graph/store.js";
 import type { NewNode } from "../../../../memory/graph/types.js";
-import { enqueueMemoryJob } from "../../../../memory/jobs-store.js";
+import {
+  enqueueMemoryJob,
+  isMemoryEnabled,
+} from "../../../../memory/jobs-store.js";
 import { memoryGraphNodes } from "../../../../memory/schema.js";
 import type {
   Playbook,
@@ -116,7 +119,9 @@ export async function executePlaybookCreate(
       sourceConversations: [`playbook:${node.id}`],
     });
 
-    enqueueMemoryJob("embed_graph_node", { nodeId: node.id });
+    if (isMemoryEnabled()) {
+      enqueueMemoryJob("embed_graph_node", { nodeId: node.id });
+    }
 
     const autonomyLabel =
       autonomyLevel === "auto"