@vellumai/assistant 0.8.1 → 0.8.2

package/src/daemon/host-app-control-proxy.ts

@@ -17,9 +17,15 @@
  * targets the user's actual desktop application, which is a host-wide
  * resource. It is acquired optimistically when `app_control_start` is
  * dispatched (storing `(conversationId, app)`) so that the synchronous
- * guard and the asynchronous host round-trip cannot race; it is released
- * when the host returns a non-running state, the dispatch fails, or the
- * owning proxy's `dispose()` fires.
+ * guard and the asynchronous host round-trip cannot race. A separate
+ * `confirmedAppControlSession` tracks the last session the host reported
+ * `running`; the rollback path on a failed `start` restores from the
+ * current confirmed pointer (not from a per-call snapshot of a sibling
+ * optimistic write), so two overlapping starts that both fail cannot
+ * leave a phantom lock — and a late-arriving `running` for an older
+ * overlapping start still updates the confirmed pointer so the lock
+ * survives a subsequent rollback of the newer start. The lock is
+ * released outright when the owning proxy's `dispose()` fires.
  *
  * `app_control_start` is the only tool that can acquire the lock — the
  * user's medium-risk approval at start time is the consent boundary. All
@@ -81,34 +87,47 @@ export interface ActiveAppControlSession {
 }
 
 /**
- * Currently active session, or `undefined` when no session is held.
+ * Currently active session, or `undefined` when no session is held. This
+ * is the optimistic value: it is set the moment a `start` is dispatched
+ * and only promoted to {@link confirmedAppControlSession} when the host
+ * returns `running`.
  *
  * Exported for test inspection only. Production code paths must not read
  * or mutate this directly — use the proxy methods.
  */
 let activeAppControlSession: ActiveAppControlSession | undefined;
 
-/** Test-only helper: read current session. */
+/**
+ * Last session whose `start` was confirmed by the host (`payload.state ===
+ * "running"`). Used as the rollback baseline so a failed start never
+ * restores a sibling in-flight optimistic write — only a session that was
+ * actually running can re-emerge from a rollback.
+ */
+let confirmedAppControlSession: ActiveAppControlSession | undefined;
+
+/** Test-only helper: read current (optimistic) session. */
 export function _getActiveAppControlSession():
   | ActiveAppControlSession
   | undefined {
   return activeAppControlSession;
 }
 
-/** Test-only helper: clear session between test cases. */
+/** Test-only helper: clear both session pointers between test cases. */
 export function _resetActiveAppControlSession(): void {
   activeAppControlSession = undefined;
+  confirmedAppControlSession = undefined;
 }
 
 /**
- * Test-only helper: prime the active session without a full `start` round-trip.
- * Useful for tests that exercise non-start tool paths and don't need to
- * verify the start flow itself.
+ * Test-only helper: prime both session pointers without a full `start`
+ * round-trip. Useful for tests that exercise non-start tool paths and
+ * don't need to verify the start flow itself.
  */
 export function _setActiveAppControlSession(
   session: ActiveAppControlSession,
 ): void {
   activeAppControlSession = session;
+  confirmedAppControlSession = session;
 }
 
 /**
@@ -236,6 +255,7 @@ export class HostAppControlProxy extends HostProxyBase<
     // belong to the active session and target the same `app`. Without this
     // gate, prompt-injected calls would bypass the start-time approval and
     // send raw input to arbitrary apps.
+    let attemptedSession: ActiveAppControlSession | undefined;
     if (input.tool === "start") {
       if (
         activeAppControlSession != null &&
@@ -253,12 +273,15 @@ export class HostAppControlProxy extends HostProxyBase<
       // synchronous guard and the asynchronous `dispatchRequest` below. Two
       // concurrent starts from different conversations would otherwise both
       // see `activeAppControlSession == null` and both pass the guard. The
-      // lock is released below if dispatch fails or the host returns a
-      // non-running state.
-      activeAppControlSession = {
+      // lock is rolled back below if dispatch fails or the host returns a
+      // non-running state — keyed on object identity so that a later
+      // overlapping start that has already replaced our write is not
+      // clobbered by a stale rollback.
+      attemptedSession = {
         conversationId: this.conversationId,
         app: input.app,
       };
+      activeAppControlSession = attemptedSession;
     } else {
       const sessionError = checkNonStartAuthorization(
         input,
@@ -278,10 +301,17 @@ export class HostAppControlProxy extends HostProxyBase<
         undefined,
         targetClientId,
       );
-      return this.handleSuccess(input, payload);
+      if (input.tool === "start") {
+        if (payload.state === "running") {
+          this.promoteStartIfCurrent(attemptedSession);
+        } else {
+          this.rollbackStartIfCurrent(attemptedSession);
+        }
+      }
+      return this.handleSuccess(payload);
     } catch (err) {
       if (input.tool === "start") {
-        this.releaseSessionIfHeld();
+        this.rollbackStartIfCurrent(attemptedSession);
       }
       if (err instanceof HostProxyRequestError) {
         if (err.reason === "timeout") {
@@ -301,10 +331,64 @@ export class HostAppControlProxy extends HostProxyBase<
     }
   }
 
+  /**
+   * Roll back the optimistic overwrite performed by a `start` when the
+   * dispatch fails or the host returns non-running. Keyed on the
+   * `attempted` reference, not just `conversationId`, so that an
+   * out-of-order failure does not clobber a newer overlapping start that
+   * already replaced our write — e.g. start A → start B (pending) →
+   * start C (success); when B later fails, the live session is C and the
+   * identity check makes our rollback a no-op rather than restoring A.
+   *
+   * Restores from the *current* `confirmedAppControlSession`, not a
+   * per-call snapshot of it. This matters when a late-arriving `running`
+   * for an older overlapping start has updated `confirmedAppControlSession`
+   * in the meantime: if A is dispatched, then C is dispatched (overwriting
+   * active), then A returns `running` (confirming A), then C returns
+   * non-running, the rollback must restore active to A — not undefined.
+   */
+  private rollbackStartIfCurrent(
+    attempted: ActiveAppControlSession | undefined,
+  ): void {
+    if (attempted != null && activeAppControlSession === attempted) {
+      activeAppControlSession = confirmedAppControlSession;
+    }
+  }
+
+  /**
+   * Promote this start's optimistic write to the confirmed pointer when
+   * the host returns `running`. Gated on conversation ownership rather
+   * than object identity: a newer overlapping start in the same
+   * conversation may have superseded our optimistic write while we were
+   * waiting on the host, but the host's `running` response for our
+   * `attempted` is still ground-truth that the lock should be held.
+   * The conversation-ownership check ensures we don't resurrect a session
+   * after `dispose()` cleared the lock or after another conversation
+   * acquired it.
+   */
+  private promoteStartIfCurrent(
+    attempted: ActiveAppControlSession | undefined,
+  ): void {
+    if (attempted == null) return;
+    if (activeAppControlSession?.conversationId !== attempted.conversationId) {
+      return;
+    }
+    confirmedAppControlSession = attempted;
+  }
+
+  /**
+   * Release both the optimistic and confirmed module-level session
+   * pointers if this proxy is the current holder. Used by `dispose()` —
+   * distinct from `rollbackStartIfCurrent` because dispose is keyed on
+   * ownership (conversationId) rather than on a specific in-flight start.
+   */
   private releaseSessionIfHeld(): void {
     if (activeAppControlSession?.conversationId === this.conversationId) {
       activeAppControlSession = undefined;
     }
+    if (confirmedAppControlSession?.conversationId === this.conversationId) {
+      confirmedAppControlSession = undefined;
+    }
   }
 
   // ---------------------------------------------------------------------------
@@ -312,7 +396,6 @@ export class HostAppControlProxy extends HostProxyBase<
   // ---------------------------------------------------------------------------
 
   private handleSuccess(
-    input: HostAppControlInput,
     payload: HostAppControlResultPayload,
   ): ToolExecutionResult {
     // Update PNG-hash loop tracking only for the "running" state — other
@@ -332,14 +415,6 @@ export class HostAppControlProxy extends HostProxyBase<
       }
     }
 
-    // The optimistic lock acquired in `request()` for `start` stays held
-    // only when the host confirms the session is running. Non-running
-    // outcomes (missing/minimized) release it so a retry or another
-    // conversation can acquire.
-    if (input.tool === "start" && payload.state !== "running") {
-      this.releaseSessionIfHeld();
-    }
-
     return this.formatResult(payload, stuck);
   }
 

package/src/daemon/lifecycle.ts

@@ -20,6 +20,7 @@ import type { AssistantConfig } from "../config/schema.js";
 import { seedInferenceProfiles } from "../config/seed-inference-profiles.js";
 import type { CesClient } from "../credential-execution/client.js";
 import { createCesClient } from "../credential-execution/client.js";
+import { refreshManagedConnectionCache } from "../credential-execution/managed-catalog.js";
 import {
   type CesProcessManager,
   CesUnavailableError,
@@ -54,11 +55,12 @@ import {
 } from "../notifications/emit-signal.js";
 import { backfillManualTokenConnections } from "../oauth/manual-token-connection.js";
 import { seedOAuthProviders } from "../oauth/seed-providers.js";
+import { installPluginRuntime } from "../plugins/external-api.js";
 import { loadUserPlugins } from "../plugins/user-loader.js";
 import { backfillGuardIfNeeded } from "../proactive-artifact/index.js";
 import { ensurePromptFiles } from "../prompts/system-prompt.js";
 import { runProviderConnectionsBackfill } from "../providers/inference/backfill.js";
-import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
+import { resolveManagedProxyContext } from "../providers/platform-proxy/context.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import {
   initAuthSigningKey,
@@ -74,7 +76,10 @@ import {
   setCesClient,
   setCesReconnect,
 } from "../security/secure-keys.js";
-import { UsageTelemetryReporter } from "../telemetry/usage-telemetry-reporter.js";
+import {
+  setUsageTelemetryReporter,
+  UsageTelemetryReporter,
+} from "../telemetry/usage-telemetry-reporter.js";
 import { registerBuiltinTtsProviders } from "../tts/providers/register-builtins.js";
 import { getDeviceId } from "../util/device-id.js";
 import { getLogger, initLogger } from "../util/logger.js";
@@ -114,7 +119,7 @@ import { backfillSlackInjectionTemplates } from "./handlers/config-slack-channel
 import { installAssistantSymlink } from "./install-symlink.js";
 import {
   maybeRebuildMemoryV2Concepts,
-  maybeSeedMemoryV2Skills,
+  rebuildBm25CorpusStatsAndReseedSkills,
 } from "./memory-v2-startup.js";
 import { processMessage } from "./process-message.js";
 import { runProfilerSweep } from "./profiler-run-store.js";
@@ -126,6 +131,7 @@ import {
 import { seedInterfaceFiles } from "./seed-files.js";
 import { DaemonServer } from "./server.js";
 import { installShutdownHandlers } from "./shutdown-handlers.js";
+import { refreshSkillCapabilityMemories } from "./skill-memory-refresh.js";
 
 const log = getLogger("lifecycle");
 let diskPressureStartupSampleTimer: ReturnType<typeof setTimeout> | null = null;
@@ -504,6 +510,25 @@ export async function runDaemon(): Promise<void> {
       }
     } // end if (dbReady)
 
+    // Populate the managed-connection cache so buildIntegrationSection()
+    // can include platform-managed OAuth connections (e.g. Twitter) in the
+    // system prompt's "Connected Services" section from the first turn.
+    // This is an HTTP-only call with no DB dependency, so it runs regardless
+    // of dbReady. A periodic refresh keeps the cache current when users
+    // connect/disconnect managed providers while the assistant is running.
+    void refreshManagedConnectionCache().catch((err) =>
+      log.warn(
+        { err },
+        "Managed connection cache refresh failed — continuing startup",
+      ),
+    );
+    const MANAGED_CONNECTION_REFRESH_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+    setInterval(() => {
+      void refreshManagedConnectionCache().catch((err) =>
+        log.warn({ err }, "Periodic managed connection cache refresh failed"),
+      );
+    }, MANAGED_CONNECTION_REFRESH_INTERVAL_MS);
+
     // Merge CLI-provided default config (from VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH)
     // into the workspace config file before profile seeding and the first
     // loadConfig() call so onboarding/platform preferences are visible to the
@@ -565,6 +590,7 @@ export async function runDaemon(): Promise<void> {
     let telemetryReporter: UsageTelemetryReporter | null = null;
     if (collectUsageData) {
       telemetryReporter = new UsageTelemetryReporter();
+      setUsageTelemetryReporter(telemetryReporter);
       telemetryReporter.start();
       log.info("Usage telemetry reporter started");
     }
@@ -648,6 +674,12 @@ export async function runDaemon(): Promise<void> {
       });
     }
 
+    // Install the `globalThis.__vellumPluginRuntime` bridge before scanning
+    // for user plugins. Plugins that touch the bridge from their module body
+    // would throw without this — see `plugins/external-api.ts` for the
+    // rationale (compiled-binary module identity).
+    installPluginRuntime();
+
     // Populate the registry with user plugins from `<workspaceDir>/plugins/*`
     // AFTER first-party plugins have already registered via their static
     // side-effect imports. User plugins may fail to load individually; a
@@ -830,25 +862,13 @@ export async function runDaemon(): Promise<void> {
         }
 
         // Build the BM25 corpus stats (per-token document frequencies and
-        // average document length) used by the v2 sparse channel. Without
-        // this, document-side sparse embeddings fall back to legacy TF-only
-        // weighting via the chicken-and-egg guard in
-        // `embed-concept-page.ts`. Fire-and-forget for the same reason as
-        // PKB reconcile — the stats are an optional optimization, never a
-        // boot-blocking dependency.
-        void (async () => {
-          try {
-            const { rebuildConceptPageCorpusStats } =
-              await import("../memory/v2/sparse-bm25.js");
-            await rebuildConceptPageCorpusStats(getWorkspaceDir());
-            log.info("Memory v2 BM25 corpus stats built");
-          } catch (err) {
-            log.warn(
-              { err },
-              "BM25 corpus-stats rebuild failed — sparse channel will fall back to TF-only until next rebuild",
-            );
-          }
-        })();
+        // average document length) used by the v2 sparse channel, then
+        // re-seed v2 skill entries so any skill vectors written during the
+        // cold-start window with the legacy TF encoder get rewritten with
+        // stemmed BM25 vectors. Fire-and-forget for the same reason as PKB
+        // reconcile — the stats and skill reseed are optional optimizations,
+        // never boot-blocking dependencies.
+        void rebuildBm25CorpusStatsAndReseedSkills(config);
 
         // Validate every concept page's frontmatter against the strict
         // schema and emit a `warn` per offender. Surfaces schema drift
@@ -876,20 +896,10 @@ export async function runDaemon(): Promise<void> {
 
       // Seed capability graph nodes (new memory graph system)
       try {
-        const {
-          seedSkillGraphNodes,
-          seedCliGraphNodes,
-          seedUninstalledCatalogSkillMemories,
-        } = await import("../memory/graph/capability-seed.js");
-        seedSkillGraphNodes();
-        maybeSeedMemoryV2Skills(config);
+        const { seedCliGraphNodes } =
+          await import("../memory/graph/capability-seed.js");
+        refreshSkillCapabilityMemories(config);
         await seedCliGraphNodes();
-        void seedUninstalledCatalogSkillMemories().catch((err) =>
-          log.warn(
-            { err },
-            "Uninstalled catalog skill memory seeding failed — continuing",
-          ),
-        );
       } catch (err) {
         log.warn({ err }, "Graph capability seeding failed — continuing");
       }

package/src/daemon/meet-host-supervisor.ts

@@ -254,10 +254,11 @@ export class MeetHostSupervisor {
   }
 
   /**
-   * Ensure the meet-host child is spawned, the IPC handshake has been
-   * received, and the manifest hash validated. Idempotent: a second
-   * call while the child is already running is a no-op; a second call
-   * during an in-flight spawn awaits the same promise.
+   * Ensure the meet-host child is spawned and the IPC handshake has
+   * been received. Idempotent: a second call while the child is
+   * already running is a no-op; a second call during an in-flight
+   * spawn awaits the same promise. Manifest hash validation is
+   * currently dormant (see {@link notifyHandshake}).
    */
   ensureRunning(): Promise<void> {
     if (this.shuttingDown) {

package/src/daemon/memory-v2-startup.ts

@@ -35,6 +35,55 @@ export function maybeSeedMemoryV2Skills(config: AssistantConfig): void {
     );
 }
 
+/**
+ * Build the v2 BM25 corpus stats (per-token document frequencies + avg doc
+ * length), then re-seed the v2 skill entries so any skills written during
+ * cold start with the legacy TF encoder get rewritten with stemmed BM25
+ * vectors. The cold-start window exists because the very first
+ * `maybeSeedMemoryV2Skills` call can race ahead of the corpus-stats build —
+ * `skill-store.runSeedOnce` falls back to `generateSparseEmbedding` while
+ * `getConceptPageCorpusStats()` is still `null`, leaving stored skill
+ * sparse vectors in a different hash space than the BM25 query vectors
+ * callers issue (see `simBatch`, `activation.selectCandidates`). Reseeding
+ * here closes that gap without operator intervention.
+ *
+ * Fire-and-forget by design — startup must not block on either step. The
+ * reseed depends on the corpus-stats build, so a corpus-stats failure
+ * short-circuits and skips the reseed (the BM25 vectors it would produce
+ * would be wrong without fresh stats). Both steps log and swallow their own
+ * errors so neither blocks startup.
+ */
+export async function rebuildBm25CorpusStatsAndReseedSkills(
+  config: AssistantConfig,
+): Promise<void> {
+  try {
+    const { rebuildConceptPageCorpusStats } =
+      await import("../memory/v2/sparse-bm25.js");
+    await rebuildConceptPageCorpusStats(getWorkspaceDir());
+    log.info("Memory v2 BM25 corpus stats built");
+  } catch (err) {
+    log.warn(
+      { err },
+      "BM25 corpus-stats rebuild failed — sparse channel will fall back to TF-only until next rebuild",
+    );
+    return;
+  }
+
+  if (!config.memory.v2.enabled) return;
+  try {
+    const { seedV2SkillEntries } = await import("../memory/v2/skill-store.js");
+    await seedV2SkillEntries({ throwOnError: true });
+    log.info(
+      "Memory v2 skill embeddings re-seeded with BM25 vectors after corpus-stats build",
+    );
+  } catch (err) {
+    log.warn(
+      { err },
+      "Failed to re-seed v2 skill entries after BM25 corpus-stats build — skills seeded during cold start may keep TF-only sparse vectors until next reseed",
+    );
+  }
+}
+
 /**
  * Reconcile the v2 concept-page Qdrant collection with the expected schema
  * and enqueue `memory_v2_reembed` when the collection is missing data.

package/src/daemon/message-protocol.ts

@@ -149,6 +149,7 @@ import type {
 export interface SubagentEvent {
   type: "subagent_event";
   subagentId: string;
+  conversationId: string;
   event: ServerMessage;
 }
 

package/src/daemon/message-types/conversations.ts

@@ -224,9 +224,18 @@ export interface ConversationTitleUpdated {
 interface ChannelBinding {
   sourceChannel: ChannelId;
   externalChatId: string;
+  externalThreadId?: string | null;
   externalUserId?: string | null;
   displayName?: string | null;
   username?: string | null;
+  slackThread?: {
+    channelId: string;
+    threadTs: string;
+    link?: {
+      appUrl?: string;
+      webUrl?: string;
+    };
+  };
 }
 
 /** Attention state metadata for a conversation's latest assistant message. */
@@ -411,6 +420,7 @@ export interface HistoryResponse {
       status: "running" | "completed" | "failed" | "aborted";
       error?: string;
       conversationId?: string;
+      objective?: string;
     };
     /** True when text or tool result content was truncated due to maxTextChars/maxToolResultChars. */
     wasTruncated?: boolean;
@@ -535,6 +545,7 @@ export type ConversationErrorCode =
   | "PROVIDER_ORDERING"
   | "PROVIDER_WEB_SEARCH"
   | "PROVIDER_NOT_CONFIGURED"
+  | "PROVIDER_INVALID_KEY"
   | "MANAGED_KEY_INVALID"
   | "CONTEXT_TOO_LARGE"
   | "CONVERSATION_ABORTED"
@@ -552,6 +563,20 @@ export interface ConversationErrorMessage {
   debugDetails?: string;
   /** Machine-readable error category for log report metadata and triage. */
   errorCategory?: string;
+  /**
+   * Name of the `provider_connections` row in play when the error occurred.
+   * Surfaced by the macOS chat banner so users know which connection to fix
+   * (e.g. an invalid API key on `my-anthropic`). Optional because some
+   * errors fire before a connection is resolved.
+   */
+  connectionName?: string;
+  /**
+   * Name of the resolved profile (`llm.activeProfile` or per-call override)
+   * in play when the error occurred. Lets the macOS chat banner point
+   * users at the right profile even when the connection name is generic.
+   * Optional because some errors fire before a profile is resolved.
+   */
+  profileName?: string;
 }
 
 /** Reason the conversation list was invalidated. */

package/src/daemon/message-types/messages.ts

@@ -235,6 +235,66 @@ export interface SecretRequest {
   allowOneTimeSend?: boolean;
 }
 
+export interface QuestionOption {
+  id: string;
+  label: string;
+  description?: string;
+}
+
+/**
+ * One entry in a batched ask-question request.
+ *
+ * `id` is daemon-assigned (e.g. `q1`, `q2`...) — the LLM neither sees nor
+ * supplies it. It exists so the client has a stable handle to post the
+ * user's answer back against. See `QuestionRequest` for the batching
+ * contract.
+ */
+export interface QuestionEntry {
+  id: string;
+  question: string;
+  description?: string;
+  /** LLM-supplied options, capped at 4. The client always renders a fixed
+   *  5th "Type something else" slot wired to a free-text response — so this
+   *  array never represents the full choice set the user sees. */
+  options: QuestionOption[];
+  /** Optional placeholder shown in the free-text input. */
+  freeTextPlaceholder?: string;
+}
+
+/**
+ * A single broadcast that carries either one or a small batch (≤5) of
+ * clarifying questions. The whole batch is one card lifecycle on the client:
+ * one render, one state machine, one response submission.
+ *
+ * Wire-compat plan: both shapes are populated on every broadcast.
+ *  - `questions[]` is the canonical shape new clients should consume.
+ *  - The flat `question` / `description` / `options` / `freeTextPlaceholder`
+ *    fields mirror `questions[0]` for backwards compat with the existing
+ *    web client, which keys off the flat fields. Once that client adopts
+ *    `questions[]`, the flat fields can be dropped (separate cleanup).
+ *
+ * Daemon callers that don't supply a batch get a one-element `questions`
+ * array synthesized from the flat fields.
+ */
+export interface QuestionRequest {
+  type: "question_request";
+  requestId: string;
+  /** Batched-question payload. Always populated (single questions are sent
+   *  as a one-element array). Each entry's `id` is daemon-assigned. */
+  questions: QuestionEntry[];
+  /** Legacy: mirrors `questions[0].question`. Kept populated for clients
+   *  that haven't adopted the batched `questions[]` shape yet. */
+  question: string;
+  /** Legacy: mirrors `questions[0].description`. */
+  description?: string;
+  /** Legacy: mirrors `questions[0].options`. */
+  options: QuestionOption[];
+  /** Legacy: mirrors `questions[0].freeTextPlaceholder`. */
+  freeTextPlaceholder?: string;
+  conversationId?: string;
+  toolUseId?: string;
+}
+
 export interface MessageComplete {
   type: "message_complete";
   conversationId?: string;
@@ -430,6 +490,7 @@ export type _MessagesServerMessages =
   | ToolResult
   | ConfirmationRequest
   | SecretRequest
+  | QuestionRequest
   | MessageComplete
   | ErrorMessage
   | MessageQueued

package/src/daemon/message-types/subagents.ts

@@ -26,6 +26,7 @@ export interface SubagentDetailResponse {
   type: "subagent_detail_response";
   subagentId: string;
   objective?: string;
+  usage?: UsageStats;
   events: Array<{
     type: string;
     content: string;

package/src/daemon/message-types/sync.ts

@@ -5,6 +5,7 @@ export const SYNC_TAGS = {
   assistantIdentity: "assistant:self:identity",
   assistantConfig: "assistant:self:config",
   assistantSounds: "assistant:self:sounds",
+  assistantSchedules: "assistant:self:schedules",
   conversationsList: "conversations:list",
 } as const;
 

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

@@ -14,7 +14,7 @@ const BASE_REMINDER_DEFAULT =
 // `memory-retrospective` feature flag is on.
 const BASE_REMINDER_RELAXED =
   "<system_reminder>" +
-  "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark — corrections (highest priority), plans, decisions, felt moments, things the user asks you to hold onto. 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." +
+  "\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>";
 

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

@@ -3,7 +3,7 @@ const BODY_DEFAULT =
   "\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 =
-  "\nStay present in this conversation. Use `remember` when something feels worth pausing to mark — corrections (highest priority), plans, decisions, felt moments, things the user asks you to hold onto. 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." +
+  "\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.";
 
 /**