@vellumai/assistant 0.8.2 → 0.8.4

package/src/daemon/pkb-reminder-builder.test.ts

@@ -2,32 +2,24 @@ import { describe, expect, test } from "bun:test";
 
 import { buildPkbReminder } from "./pkb-reminder-builder.js";
 
-// Byte-for-byte fixture of the default (non-relaxed) PKB reminder. Asserted
-// verbatim so that any future edit to the BODY text is caught by tests.
-const BASE_REMINDER_DEFAULT =
-  "<system_reminder>" +
-  "\n**CRITICAL:** Call `remember` this turn for anything concrete the user said — facts, preferences, plans, names, dates, decisions, corrections, felt moments. Default to remembering; skip only obvious noise. This should be your most frequently used tool." +
-  "\nIf you're unsure about something that may live in the workspace — past decisions, prior conversations, files — use `recall` before asking or guessing." +
-  "\n</system_reminder>";
-
-// Byte-for-byte fixture of the relaxed PKB reminder used when the
-// `memory-retrospective` feature flag is on.
-const BASE_REMINDER_RELAXED =
+// Byte-for-byte fixture of the PKB reminder. Asserted verbatim so that any
+// future edit to the BODY text is caught by tests.
+const BASE_REMINDER =
   "<system_reminder>" +
   "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark — corrections (highest priority), plans, decisions, felt moments. You don't have to capture everything in the moment — a retrospective pass reviews this conversation in the background and saves what you didn't capture." +
   "\nIf you're unsure about something that may live in the workspace — past decisions, prior conversations, files — use `recall` before asking or guessing." +
   "\n</system_reminder>";
 
-describe("buildPkbReminder — default body (relaxed=false)", () => {
+describe("buildPkbReminder", () => {
   test("empty hints returns exact base reminder byte-for-byte", () => {
-    expect(buildPkbReminder([], false)).toBe(BASE_REMINDER_DEFAULT);
+    expect(buildPkbReminder([])).toBe(BASE_REMINDER);
   });
 
   test("single hint renders one bullet with no duplicates or trailing blank line", () => {
-    const out = buildPkbReminder(["projects/alpha.md"], false);
+    const out = buildPkbReminder(["projects/alpha.md"]);
     const expected =
       "<system_reminder>" +
-      "\n**CRITICAL:** Call `remember` this turn for anything concrete the user said — facts, preferences, plans, names, dates, decisions, corrections, felt moments. Default to remembering; skip only obvious noise. This should be your most frequently used tool." +
+      "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark — corrections (highest priority), plans, decisions, felt moments. You don't have to capture everything in the moment — a retrospective pass reviews this conversation in the background and saves what you didn't capture." +
       "\nIf you're unsure about something that may live in the workspace — past decisions, prior conversations, files — use `recall` before asking or guessing." +
       "\nBased on the current context, these files look especially relevant:" +
       "\n- projects/alpha.md" +
@@ -44,10 +36,10 @@ describe("buildPkbReminder — default body (relaxed=false)", () => {
 
   test("three hints render all three in order", () => {
     const hints = ["a.md", "sub/b.md", "c/d/e.md"];
-    const out = buildPkbReminder(hints, false);
+    const out = buildPkbReminder(hints);
     const expected =
       "<system_reminder>" +
-      "\n**CRITICAL:** Call `remember` this turn for anything concrete the user said — facts, preferences, plans, names, dates, decisions, corrections, felt moments. Default to remembering; skip only obvious noise. This should be your most frequently used tool." +
+      "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark — corrections (highest priority), plans, decisions, felt moments. You don't have to capture everything in the moment — a retrospective pass reviews this conversation in the background and saves what you didn't capture." +
       "\nIf you're unsure about something that may live in the workspace — past decisions, prior conversations, files — use `recall` before asking or guessing." +
       "\nBased on the current context, these files look especially relevant:" +
       "\n- a.md" +
@@ -67,7 +59,7 @@ describe("buildPkbReminder — default body (relaxed=false)", () => {
 
   test("hints with special chars (< and &) are emitted verbatim (no escaping)", () => {
     const hints = ["weird<name>.md", "foo&bar.md"];
-    const out = buildPkbReminder(hints, false);
+    const out = buildPkbReminder(hints);
     expect(out).toContain("- weird<name>.md");
     expect(out).toContain("- foo&bar.md");
     // Ensure no HTML-style escaping happened.
@@ -75,38 +67,3 @@ describe("buildPkbReminder — default body (relaxed=false)", () => {
     expect(out).not.toContain("&amp;");
   });
 });
-
-describe("buildPkbReminder — relaxed body (relaxed=true)", () => {
-  test("empty hints returns the relaxed base reminder byte-for-byte", () => {
-    expect(buildPkbReminder([], true)).toBe(BASE_REMINDER_RELAXED);
-  });
-
-  test("relaxed BODY does NOT contain the default high-pressure phrasing", () => {
-    const out = buildPkbReminder([], true);
-    expect(out).not.toContain("**CRITICAL:**");
-    expect(out).not.toContain("most frequently used tool");
-    expect(out).not.toContain("Default to remembering");
-  });
-
-  test("relaxed BODY mentions the retrospective backstop framing", () => {
-    const out = buildPkbReminder([], true);
-    expect(out).toContain("Stay present");
-    expect(out).toContain("retrospective pass");
-  });
-
-  test("hints render below the relaxed body in the same shape as default", () => {
-    const out = buildPkbReminder(["projects/alpha.md"], true);
-    expect(out).toContain("- projects/alpha.md");
-    expect(out).toContain(
-      "Based on the current context, these files look especially relevant:",
-    );
-    // Should still close cleanly with no double newline before the tag.
-    expect(out.includes("\n\n</system_reminder>")).toBe(false);
-  });
-});
-
-describe("buildPkbReminder — relaxed vs default differ", () => {
-  test("the two BODY variants are NOT byte-identical", () => {
-    expect(buildPkbReminder([], false)).not.toBe(buildPkbReminder([], true));
-  });
-});

package/src/daemon/pkb-reminder-builder.ts

@@ -1,8 +1,4 @@
-const BODY_DEFAULT =
-  "\n**CRITICAL:** Call `remember` this turn for anything concrete the user said — facts, preferences, plans, names, dates, decisions, corrections, felt moments. Default to remembering; skip only obvious noise. This should be your most frequently used tool." +
-  "\nIf you're unsure about something that may live in the workspace — past decisions, prior conversations, files — use `recall` before asking or guessing.";
-
-const BODY_RELAXED =
+const BODY =
   "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark — corrections (highest priority), plans, decisions, felt moments. You don't have to capture everything in the moment — a retrospective pass reviews this conversation in the background and saves what you didn't capture." +
   "\nIf you're unsure about something that may live in the workspace — past decisions, prior conversations, files — use `recall` before asking or guessing.";
 
@@ -15,23 +11,12 @@ const BODY_RELAXED =
  * hint. Hints are emitted verbatim — they are trusted internal paths, not
  * user input, so no escaping is performed.
  *
- * The `relaxed` flag selects between the default high-pressure body and the
- * relaxed "judgment framing" body used when the `memory-retrospective`
- * feature flag is on. With the flag on, the in-conversation remember pressure
- * eases because the retrospective is the backstop. Callers must pass
- * `relaxed` explicitly — no default — so the contract is visible at every
- * call site.
- *
  * Caller is responsible for capping the hints array at 3 entries.
  */
-export function buildPkbReminder(
-  hints: ReadonlyArray<string>,
-  relaxed: boolean,
-): string {
-  const body = relaxed ? BODY_RELAXED : BODY_DEFAULT;
+export function buildPkbReminder(hints: ReadonlyArray<string>): string {
   if (hints.length === 0) {
-    return `<system_reminder>${body}\n</system_reminder>`;
+    return `<system_reminder>${BODY}\n</system_reminder>`;
   }
   const bullets = hints.map((h) => `- ${h}`).join("\n");
-  return `<system_reminder>${body}\nBased on the current context, these files look especially relevant:\n${bullets}\n</system_reminder>`;
+  return `<system_reminder>${BODY}\nBased on the current context, these files look especially relevant:\n${bullets}\n</system_reminder>`;
 }

package/src/daemon/plugin-source-watcher.ts

@@ -12,10 +12,32 @@
  * through a static singleton so tool side-effects can call
  * `PluginSourceWatcher.getInstance().ensureStarted()` directly without an
  * intermediate module-level injection.
+ *
+ * ## Linux/Bun recursive-watch caveat
+ *
+ * `fs.watch(dir, { recursive: true })` on Linux (and the equivalent under
+ * Bun, which uses the platform inotify path) does **not** dynamically
+ * attach to subdirectories created after the watch was established. The
+ * kernel fires exactly one event when the new top-level entry appears,
+ * and any writes inside that new subtree are silently dropped.
+ *
+ * Reproducer (against an empty watched root):
+ *
+ *     mkdir plugin/                      → event "plugin"
+ *     mkdir plugin/hooks/                → no event delivered
+ *     echo x > plugin/hooks/file.ts      → no event delivered
+ *
+ * To work around this we close + reopen the watcher on every event (with
+ * a coalescing debounce). Reopening walks the tree from scratch and
+ * re-subscribes to every directory that currently exists, so subsequent
+ * writes anywhere under the new subtree are delivered normally. We also
+ * rescan top-level entries after the swap and dispatch a rebuild for any
+ * plugin not yet in the registry, which closes the close→reopen gap.
  */
 
-import { type FSWatcher, mkdirSync, watch } from "node:fs";
+import { type FSWatcher, mkdirSync, readdirSync, watch } from "node:fs";
 
+import { getRegisteredPlugin } from "../plugins/registry.js";
 import { DebouncerMap } from "../util/debounce.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspacePluginsDir } from "../util/platform.js";
@@ -25,6 +47,12 @@ const log = getLogger("plugin-source-watcher");
 
 const PLUGIN_SOURCE_DEBOUNCE_MS = 500;
 
+/**
+ * Single shared debouncer key for the "restart the watcher" path. Bursty
+ * events for many plugin names all collapse to one restart.
+ */
+const WATCHER_RESTART_KEY = "__restart__";
+
 /**
  * Extract the plugin's top-level directory name from a relative path within
  * the plugins root. Returns null for a stray file directly in `plugins/`
@@ -36,10 +64,12 @@ function resolvePluginNameFromRelPath(relPath: string): string | null {
     // Bare entry under plugins/ — fs.watch reports these when a new
     // directory is first created. We treat the name as the plugin name and
     // let the install path decide whether it's a real plugin.
-    return relPath.length > 0 ? relPath : null;
+    if (relPath.length === 0 || relPath.startsWith(".")) return null;
+    return relPath;
   }
   const dirName = relPath.slice(0, slashIdx);
-  return dirName.length > 0 ? dirName : null;
+  if (dirName.length === 0 || dirName.startsWith(".")) return null;
+  return dirName;
 }
 
 export class PluginSourceWatcher {
@@ -70,6 +100,14 @@ export class PluginSourceWatcher {
     defaultDelayMs: PLUGIN_SOURCE_DEBOUNCE_MS,
     maxEntries: 50,
   });
+  /**
+   * Coalesces watcher-restart requests across bursty events. See
+   * {@link restartWatcher} for why we restart on every event.
+   */
+  private restartDebouncer = new DebouncerMap({
+    defaultDelayMs: PLUGIN_SOURCE_DEBOUNCE_MS,
+    maxEntries: 1,
+  });
 
   start(): void {
     this.started = true;
@@ -89,6 +127,7 @@ export class PluginSourceWatcher {
   stop(): void {
     this.started = false;
     this.debouncer.cancelAll();
+    this.restartDebouncer.cancelAll();
     if (this.watcher) {
       this.watcher.close();
       this.watcher = null;
@@ -99,6 +138,89 @@ export class PluginSourceWatcher {
     return reregisterExternalPlugin(pluginName);
   }
 
+  /**
+   * Close the current FSWatcher and open a fresh one on the same root.
+   *
+   * Workaround for the Linux/Bun recursive-watch limitation documented at
+   * the top of this file. Reopening re-walks the tree and re-subscribes
+   * to every directory that exists at that moment, including any subtree
+   * that grew under the watched root since the previous watcher started.
+   *
+   * Belt-and-suspenders: after the swap, we rescan top-level entries and
+   * dispatch a rebuild for any plugin not yet in the registry — this
+   * closes the (sub-millisecond) gap between close and reopen during
+   * which a brand-new plugin's first event could be lost.
+   *
+   * Failure mode: if the reopen fails, keep the previous watcher active.
+   * It may still miss newly-created subtrees, but it preserves existing
+   * plugin source coverage instead of degrading to no watcher at all.
+   */
+  private restartWatcher(): void {
+    if (!this.started) return;
+
+    const oldWatcher = this.watcher;
+    this.watcher = null; // tryWatch returns early when non-null
+    this.tryWatch();
+
+    if (this.watcher === null) {
+      // Keep the previous watcher alive if the replacement failed. It may not
+      // cover newly-created subtrees, but it is still better than dropping all
+      // plugin source coverage.
+      this.watcher = oldWatcher;
+      log.warn(
+        "Plugin source watcher restart failed; keeping previous watcher active",
+      );
+      return;
+    }
+
+    if (oldWatcher) {
+      try {
+        oldWatcher.close();
+      } catch (err) {
+        log.warn({ err }, "Failed to close previous plugin watcher");
+      }
+    }
+
+    this.rescanPlugins();
+  }
+
+  /**
+   * Schedule a rebuild for every top-level entry under the plugins dir
+   * that isn't already in the registry. Called after a successful
+   * {@link restartWatcher} to catch new-plugin events that may have been
+   * lost during the close→reopen swap.
+   *
+   * Existing plugins are skipped — their normal change events are
+   * delivered through the freshly-attached watcher.
+   */
+  private rescanPlugins(): void {
+    let pluginsDir: string;
+    try {
+      pluginsDir = getWorkspacePluginsDir();
+    } catch {
+      return;
+    }
+
+    let entries: string[];
+    try {
+      entries = readdirSync(pluginsDir);
+    } catch (err) {
+      log.warn({ err, pluginsDir }, "Failed to rescan plugins directory");
+      return;
+    }
+
+    for (const entry of entries) {
+      // Skip dotfiles / dot-directories (e.g. macOS `.DS_Store`, npm cache).
+      if (entry.startsWith(".")) continue;
+      // Existing plugins ride the watcher's normal event delivery. The
+      // rescan is purely to catch installs whose first event was lost.
+      if (getRegisteredPlugin(entry) !== undefined) continue;
+      this.debouncer.schedule(`plugin:${entry}`, () => {
+        void this.onChange(entry);
+      });
+    }
+  }
+
   private tryWatch(): void {
     if (this.watcher) return;
 
@@ -130,9 +252,19 @@ export class PluginSourceWatcher {
           if (!filename) return;
           const pluginName = resolvePluginNameFromRelPath(filename);
           if (!pluginName) return;
+
+          // Per-plugin rebuild — debounced under the plugin name so bursty
+          // edits collapse to a single rebuild.
           this.debouncer.schedule(`plugin:${pluginName}`, () => {
             void this.onChange(pluginName);
           });
+
+          // Refresh the watcher to pick up any subtree that grew under us.
+          // Coalesced across all plugin names; single watcher restart per
+          // event burst. See restartWatcher for the rationale.
+          this.restartDebouncer.schedule(WATCHER_RESTART_KEY, () => {
+            this.restartWatcher();
+          });
         },
       );
       log.info({ pluginsDir }, "Plugin source watcher started");

package/src/daemon/process-message.ts

@@ -31,13 +31,17 @@ import { updateMetaFile } from "../memory/conversation-disk-view.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
+import { getSubagentManager } from "../subagent/index.js";
 import { getLogger } from "../util/logger.js";
 import type { Conversation } from "./conversation.js";
 import {
   buildSlackMetaForPersistence,
   serializePersistedUserMessageContent,
 } from "./conversation-messaging.js";
-import { formatCompactResult } from "./conversation-process.js";
+import {
+  formatCleanResult,
+  formatCompactResult,
+} from "./conversation-process.js";
 import { resolveChannelCapabilities } from "./conversation-runtime-assembly.js";
 import {
   buildSlashContextForContent,
@@ -253,7 +257,7 @@ export async function processMessage(
   options?: ProcessMessageOptions,
   sourceChannel?: string,
   sourceInterface?: string,
-): Promise<{ messageId: string }> {
+): Promise<{ messageId: string; assistantMessageId?: string }> {
   const conversationOptions = stripPerTurnObservers(options);
   const { conversation, attachments } = await prepareConversationForMessage(
     conversationId,
@@ -369,7 +373,7 @@ export async function processMessage(
     }
 
     const assistantMsg = createAssistantMessage(slashResult.message);
-    await addMessage(
+    const persistedAssistant = await addMessage(
       conversationId,
       "assistant",
       JSON.stringify(assistantMsg.content),
@@ -377,7 +381,10 @@ export async function processMessage(
     );
     conversation.getMessages().push(assistantMsg);
     publishConversationMessagesChanged(conversationId);
-    return { messageId: persisted.id };
+    return {
+      messageId: persisted.id,
+      assistantMessageId: persistedAssistant.id,
+    };
   }
 
   if (slashResult.kind === "compact") {
@@ -427,7 +434,7 @@ export async function processMessage(
     });
     const responseText = formatCompactResult(result);
     const assistantMsg = createAssistantMessage(responseText);
-    await addMessage(
+    const persistedAssistant = await addMessage(
       conversationId,
       "assistant",
       JSON.stringify(assistantMsg.content),
@@ -435,7 +442,64 @@ export async function processMessage(
     );
     conversation.getMessages().push(assistantMsg);
     publishConversationMessagesChanged(conversationId);
-    return { messageId: persisted.id };
+    return {
+      messageId: persisted.id,
+      assistantMessageId: persistedAssistant.id,
+    };
+  }
+
+  if (slashResult.kind === "clean") {
+    const serverTurnCtx = conversation.getTurnChannelContext();
+    const serverProvenance = provenanceFromTrustContext(
+      conversation.trustContext,
+    );
+    const cleanChannelMeta = {
+      ...serverProvenance,
+      ...(serverTurnCtx
+        ? {
+            userMessageChannel: serverTurnCtx.userMessageChannel,
+            assistantMessageChannel: serverTurnCtx.assistantMessageChannel,
+          }
+        : {}),
+      ...(serverInterfaceCtx
+        ? {
+            userMessageInterface: serverInterfaceCtx.userMessageInterface,
+            assistantMessageInterface:
+              serverInterfaceCtx.assistantMessageInterface,
+          }
+        : {}),
+    };
+    const cleanUserMeta = slackMeta
+      ? { ...cleanChannelMeta, slackMeta }
+      : cleanChannelMeta;
+    const cleanMsg = createUserMessage(content, attachments);
+    const persisted = await addMessage(
+      conversationId,
+      "user",
+      serializePersistedUserMessageContent(
+        content,
+        attachments,
+        options?.displayContent,
+      ),
+      cleanUserMeta,
+    );
+    conversation.getMessages().push(cleanMsg);
+
+    const result = await conversation.forceClean();
+    const responseText = formatCleanResult(result);
+    const assistantMsg = createAssistantMessage(responseText);
+    const persistedAssistant = await addMessage(
+      conversationId,
+      "assistant",
+      JSON.stringify(assistantMsg.content),
+      cleanChannelMeta,
+    );
+    conversation.getMessages().push(assistantMsg);
+    publishConversationMessagesChanged(conversationId);
+    return {
+      messageId: persisted.id,
+      assistantMessageId: persistedAssistant.id,
+    };
   }
 
   const resolvedContent = slashResult.content;
@@ -455,19 +519,16 @@ export async function processMessage(
 
   if (options?.isInteractive === true) {
     conversation.updateClient(broadcastMessage, false);
+    getSubagentManager().updateParentSender(conversationId, broadcastMessage);
   }
 
   try {
-    conversation.setSlackRuntimeContextNotice(
-      options?.slackRuntimeContextNotice,
-    );
     await conversation.runAgentLoop(resolvedContent, messageId, emitEvent, {
       isInteractive: options?.isInteractive ?? false,
       isUserMessage: true,
       ...(options?.callSite ? { callSite: options.callSite } : {}),
     });
   } finally {
-    conversation.setSlackRuntimeContextNotice(undefined);
     if (
       options?.isInteractive === true &&
       conversation.getCurrentSender() === broadcastMessage
@@ -521,9 +582,9 @@ export async function processMessageInBackground(
 
   if (options?.isInteractive === true) {
     conversation.updateClient(broadcastMessage, false);
+    getSubagentManager().updateParentSender(conversationId, broadcastMessage);
   }
 
-  conversation.setSlackRuntimeContextNotice(options?.slackRuntimeContextNotice);
   conversation
     .runAgentLoop(content, messageId, emitEvent, {
       isInteractive: options?.isInteractive ?? false,
@@ -531,7 +592,6 @@ export async function processMessageInBackground(
       ...(options?.callSite ? { callSite: options.callSite } : {}),
     })
     .finally(() => {
-      conversation.setSlackRuntimeContextNotice(undefined);
       if (
         options?.isInteractive === true &&
         conversation.getCurrentSender() === broadcastMessage

package/src/daemon/query-complexity-router.ts

@@ -0,0 +1,75 @@
+import {
+  createTimeout,
+  extractText,
+  getConfiguredProvider,
+  userMessage,
+} from "../providers/provider-send-message.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("query-complexity-router");
+
+export type ComplexityTier = "speed" | "balanced" | "quality";
+
+const CLASSIFICATION_TIMEOUT_MS = 5_000;
+
+const SYSTEM_PROMPT = `You are a query complexity classifier. Given a user message, classify its complexity into exactly one tier.
+
+Reply with a single word — one of: speed, balanced, quality
+
+- speed: trivial queries — greetings, acknowledgements, simple yes/no questions, basic factual lookups, short commands, small talk
+- balanced: moderate queries — explanations, summaries, standard coding tasks, general conversation, most everyday requests
+- quality: complex queries — deep analysis, long-form creative writing, complex multi-step reasoning, debugging intricate code, architectural design, research synthesis
+
+When uncertain, reply "balanced".`;
+
+export async function classifyQueryComplexity(
+  messageText: string,
+): Promise<ComplexityTier | null> {
+  const provider = await getConfiguredProvider("queryComplexityRouter");
+  if (!provider) {
+    log.warn("No provider available for query complexity routing");
+    return null;
+  }
+
+  const truncated =
+    messageText.length > 2000 ? messageText.slice(0, 2000) : messageText;
+
+  const { signal, cleanup } = createTimeout(CLASSIFICATION_TIMEOUT_MS);
+  try {
+    const response = await provider.sendMessage(
+      [userMessage(truncated)],
+      undefined,
+      SYSTEM_PROMPT,
+      { signal },
+    );
+    const text = extractText(response).toLowerCase().trim();
+    if (text === "speed" || text === "balanced" || text === "quality") {
+      return text;
+    }
+    // Parse partial matches (model might say "speed." or "quality - because...")
+    if (text.startsWith("speed")) return "speed";
+    if (text.startsWith("quality")) return "quality";
+    if (text.startsWith("balanced")) return "balanced";
+    log.warn({ raw: text }, "Unexpected classifier output, defaulting to null");
+    return null;
+  } catch (err) {
+    if (signal.aborted) {
+      log.warn("Query complexity classification timed out");
+    } else {
+      log.warn({ err }, "Query complexity classification failed");
+    }
+    return null;
+  } finally {
+    cleanup();
+  }
+}
+
+const PROFILE_MAP: Record<ComplexityTier, string> = {
+  speed: "cost-optimized",
+  balanced: "balanced",
+  quality: "quality-optimized",
+};
+
+export function complexityTierToProfileKey(tier: ComplexityTier): string {
+  return PROFILE_MAP[tier];
+}

package/src/daemon/skill-memory-refresh.ts

@@ -5,7 +5,10 @@ import {
   seedUninstalledCatalogSkillMemories,
 } from "../memory/graph/capability-seed.js";
 import { getLogger } from "../util/logger.js";
-import { maybeSeedMemoryV2Skills } from "./memory-v2-startup.js";
+import {
+  maybeSeedMemoryV2CliCommands,
+  maybeSeedMemoryV2Skills,
+} from "./memory-v2-startup.js";
 
 const log = getLogger("skill-memory-refresh");
 
@@ -14,6 +17,7 @@ export function refreshSkillCapabilityMemories(
 ): void {
   seedSkillGraphNodes();
   maybeSeedMemoryV2Skills(config);
+  maybeSeedMemoryV2CliCommands(config);
   void seedUninstalledCatalogSkillMemories()
     .then(() => {
       // Re-run after the async catalog fetch populates the cache so stale

package/src/daemon/trust-context.ts

@@ -25,6 +25,12 @@ export interface TrustContext {
   requesterSenderDisplayName?: string;
   /** Guardian-managed display name from the contact record. */
   requesterMemberDisplayName?: string;
+  /** Raw timezone for the requester, when supplied by the source channel. */
+  requesterTimezone?: string;
+  /** Compact timezone label for the requester, when supplied by the source channel. */
+  requesterTimezoneLabel?: string;
+  /** Raw timezone offset in seconds for the requester, when supplied by the source channel. */
+  requesterTimezoneOffsetSeconds?: number;
   /** Canonical external user ID of the requester (the current actor). */
   requesterExternalUserId?: string;
   /** Chat/conversation ID the requester is interacting through. */

package/src/daemon/wake-target-adapter.ts

@@ -135,6 +135,8 @@ function translateAgentEventToServerMessage(
     case "input_json_delta":
     case "usage":
     case "error":
+    case "provider_error":
+    case "agent_loop_exit":
       return null;
   }
 }