@vellumai/assistant 0.7.3 → 0.8.1

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

@@ -147,8 +147,26 @@ export interface ToolResult {
   matchedTrustRuleId?: string;
   /** Whether the daemon is running in a containerized (Docker) environment. */
   isContainerized?: boolean;
-  /** Scope options ladder for the rule editor modal (narrowest to broadest). */
+  /**
+   * Display-only ladder of scope option labels for the rule editor
+   * (narrowest to broadest). The `pattern` here is regex-style and is
+   * NOT a valid trust rule pattern. Clients must use
+   * `riskAllowlistOptions` for the pattern that gets saved.
+   */
   riskScopeOptions?: Array<{ pattern: string; label: string }>;
+  /**
+   * Allowlist options for the rule editor save path (narrowest to
+   * broadest). Each `pattern` is a Minimatch-glob compatible string —
+   * what the gateway actually matches against. Mirrors the
+   * `allowlistOptions` field on `ConfirmationRequest`. May be absent
+   * for tools whose classifier does not produce an allowlist (e.g.
+   * web-risk classifier, MCP tools without classifier coverage).
+   */
+  riskAllowlistOptions?: Array<{
+    label: string;
+    description: string;
+    pattern: string;
+  }>;
   /** Directory scope ladder for the rule editor modal (narrowest to broadest). */
   riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
   /** How the approval decision was reached: prompted, auto, blocked, or unknown (legacy). */
@@ -222,8 +240,14 @@ export interface MessageComplete {
   conversationId?: string;
   attachments?: UserMessageAttachment[];
   attachmentWarnings?: string[];
-  /** Database ID of the persisted assistant message, if any. */
+  /** Database ID of the final persisted assistant row, if any. */
   messageId?: string;
+  /**
+   * Database ID used by clients for the rendered assistant bubble. Tool turns
+   * may persist multiple assistant rows; this matches the history row that
+   * survives query-time merging.
+   */
+  displayMessageId?: string;
   /**
    * Distinguishes a real main-turn completion from auxiliary events such as
    * call transcripts, call summaries, and watch notifier outputs. Clients
@@ -352,6 +376,8 @@ export interface ConversationInferenceProfileUpdated {
   type: "conversation_inference_profile_updated";
   conversationId: string;
   profile: string | null;
+  sessionId?: string | null;
+  expiresAt?: number | null;
 }
 
 export type TraceEventKind =

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

@@ -0,0 +1,60 @@
+import { z } from "zod";
+
+export const SYNC_TAGS = {
+  assistantAvatar: "assistant:self:avatar",
+  assistantIdentity: "assistant:self:identity",
+  assistantConfig: "assistant:self:config",
+  assistantSounds: "assistant:self:sounds",
+  conversationsList: "conversations:list",
+} as const;
+
+export type KnownSyncInvalidationTag =
+  (typeof SYNC_TAGS)[keyof typeof SYNC_TAGS];
+
+export type ConversationSyncInvalidationTag =
+  | `conversation:${string}:messages`
+  | `conversation:${string}:metadata`;
+
+export type SyncInvalidationTag =
+  | KnownSyncInvalidationTag
+  | ConversationSyncInvalidationTag
+  | (string & {});
+
+export interface SyncChangedMessage {
+  type: "sync_changed";
+  tags: SyncInvalidationTag[];
+}
+
+export const SyncInvalidationTagSchema = z.string().min(1);
+
+export const SyncChangedMessageSchema = z
+  .object({
+    type: z.literal("sync_changed"),
+    tags: z.array(SyncInvalidationTagSchema).min(1),
+  })
+  .strict();
+
+export function conversationMessagesSyncTag(
+  conversationId: string,
+): ConversationSyncInvalidationTag {
+  return `conversation:${conversationId}:messages`;
+}
+
+export function conversationMetadataSyncTag(
+  conversationId: string,
+): ConversationSyncInvalidationTag {
+  return `conversation:${conversationId}:metadata`;
+}
+
+export function buildSyncChangedMessage(
+  tags: SyncInvalidationTag[],
+): SyncChangedMessage {
+  const dedupedTags = Array.from(new Set(tags));
+  const parsed = SyncChangedMessageSchema.parse({
+    type: "sync_changed",
+    tags: dedupedTags,
+  });
+  return parsed as SyncChangedMessage;
+}
+
+export type _SyncInvalidationServerMessages = SyncChangedMessage;

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

@@ -2,26 +2,33 @@ import { describe, expect, test } from "bun:test";
 
 import { buildPkbReminder } from "./pkb-reminder-builder.js";
 
-// Byte-for-byte fixture of the base PKB reminder.
-const BASE_REMINDER =
+// 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>" +
-  "\nCall `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." +
+  "\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." +
-  "\nRead any unread workspace files that look even partially relevant." +
   "\n</system_reminder>";
 
-describe("buildPkbReminder", () => {
+// Byte-for-byte fixture of the relaxed PKB reminder used when the
+// `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." +
+  "\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)", () => {
   test("empty hints returns exact base reminder byte-for-byte", () => {
-    expect(buildPkbReminder([])).toBe(BASE_REMINDER);
+    expect(buildPkbReminder([], false)).toBe(BASE_REMINDER_DEFAULT);
   });
 
   test("single hint renders one bullet with no duplicates or trailing blank line", () => {
-    const out = buildPkbReminder(["projects/alpha.md"]);
+    const out = buildPkbReminder(["projects/alpha.md"], false);
     const expected =
       "<system_reminder>" +
-      "\nCall `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." +
+      "\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." +
-      "\nRead any unread workspace files that look even partially relevant." +
       "\nBased on the current context, these files look especially relevant:" +
       "\n- projects/alpha.md" +
       "\n</system_reminder>";
@@ -37,12 +44,11 @@ describe("buildPkbReminder", () => {
 
   test("three hints render all three in order", () => {
     const hints = ["a.md", "sub/b.md", "c/d/e.md"];
-    const out = buildPkbReminder(hints);
+    const out = buildPkbReminder(hints, false);
     const expected =
       "<system_reminder>" +
-      "\nCall `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." +
+      "\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." +
-      "\nRead any unread workspace files that look even partially relevant." +
       "\nBased on the current context, these files look especially relevant:" +
       "\n- a.md" +
       "\n- sub/b.md" +
@@ -61,7 +67,7 @@ describe("buildPkbReminder", () => {
 
   test("hints with special chars (< and &) are emitted verbatim (no escaping)", () => {
     const hints = ["weird<name>.md", "foo&bar.md"];
-    const out = buildPkbReminder(hints);
+    const out = buildPkbReminder(hints, false);
     expect(out).toContain("- weird<name>.md");
     expect(out).toContain("- foo&bar.md");
     // Ensure no HTML-style escaping happened.
@@ -69,3 +75,38 @@ describe("buildPkbReminder", () => {
     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,7 +1,10 @@
-const BODY =
-  "\nCall `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." +
-  "\nRead any unread workspace files that look even partially relevant.";
+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 =
+  "\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." +
+  "\nIf you're unsure about something that may live in the workspace — past decisions, prior conversations, files — use `recall` before asking or guessing.";
 
 /**
  * Render the PKB system_reminder text, optionally with a bulleted list of
@@ -12,12 +15,23 @@ const BODY =
  * 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>): string {
+export function buildPkbReminder(
+  hints: ReadonlyArray<string>,
+  relaxed: boolean,
+): string {
+  const body = relaxed ? BODY_RELAXED : BODY_DEFAULT;
   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/process-message.ts

@@ -15,7 +15,6 @@ import {
   type InterfaceId,
   parseChannelId,
   parseInterfaceId,
-  supportsHostProxy,
 } from "../channels/types.js";
 import {
   getAttachmentsByIds,
@@ -47,10 +46,41 @@ import {
 import type { ConversationCreateOptions } from "./handlers/shared.js";
 import { HostAppControlProxy } from "./host-app-control-proxy.js";
 import { HostCuProxy } from "./host-cu-proxy.js";
-import { preactivateHostProxySkills } from "./host-proxy-preactivation.js";
+import {
+  preactivateHostProxySkills,
+  shouldAttachHostProxyForCapability,
+} from "./host-proxy-preactivation.js";
+import type { ServerMessage } from "./message-protocol.js";
 
 const log = getLogger("process-message");
 
+type ProcessMessageOptions = ConversationCreateOptions & {
+  /** Per-turn observer for live agent-loop events. Does not replace SSE broadcast. */
+  onEvent?: (msg: ServerMessage) => void;
+};
+
+function stripPerTurnObservers(
+  options?: ProcessMessageOptions,
+): ConversationCreateOptions | undefined {
+  if (!options) return undefined;
+  const { onEvent: _onEvent, ...conversationOptions } = options;
+  return conversationOptions;
+}
+
+function buildEventEmitter(
+  observer?: (msg: ServerMessage) => void,
+): (msg: ServerMessage) => void {
+  if (!observer) return broadcastMessage;
+  return (msg) => {
+    broadcastMessage(msg);
+    try {
+      observer(msg);
+    } catch (err) {
+      log.warn({ err, messageType: msg.type }, "Agent event observer failed");
+    }
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Turn-context resolution helpers
 // ---------------------------------------------------------------------------
@@ -154,7 +184,7 @@ async function prepareConversationForMessage(
     );
   }
   // CU is per-conversation (owns step count, AX tree history, loop detection).
-  if (supportsHostProxy(resolvedInterface, "host_cu")) {
+  if (shouldAttachHostProxyForCapability("host_cu", resolvedInterface)) {
     if (!conversation.isProcessing() || !conversation.hostCuProxy) {
       conversation.setHostCuProxy(new HostCuProxy());
     }
@@ -162,10 +192,12 @@ async function prepareConversationForMessage(
     conversation.setHostCuProxy(undefined);
   }
   // App-control mirrors CU's per-conversation lifecycle. The proxy attaches
-  // unconditionally when the client supports the capability — feature-flag
-  // gating is enforced by the skill-projection layer via SKILL.md
-  // frontmatter, so an attached proxy is harmless when the flag is off.
-  if (supportsHostProxy(resolvedInterface, "host_app_control")) {
+  // unconditionally when the capability is reachable — feature-flag gating
+  // is enforced by the skill-projection layer via SKILL.md frontmatter, so
+  // an attached proxy is harmless when the flag is off.
+  if (
+    shouldAttachHostProxyForCapability("host_app_control", resolvedInterface)
+  ) {
     if (!conversation.isProcessing() || !conversation.hostAppControlProxy) {
       conversation.setHostAppControlProxy(
         new HostAppControlProxy(conversationId),
@@ -214,18 +246,20 @@ export async function processMessage(
   conversationId: string,
   content: string,
   attachmentIds?: string[],
-  options?: ConversationCreateOptions,
+  options?: ProcessMessageOptions,
   sourceChannel?: string,
   sourceInterface?: string,
 ): Promise<{ messageId: string }> {
+  const conversationOptions = stripPerTurnObservers(options);
   const { conversation, attachments } = await prepareConversationForMessage(
     conversationId,
     content,
     attachmentIds,
-    options,
+    conversationOptions,
     sourceChannel,
     sourceInterface,
   );
+  const emitEvent = buildEventEmitter(options?.onEvent);
 
   const serverInterfaceCtx = conversation.getTurnInterfaceContext();
   const slashContext = buildSlashContextForContent(content, {
@@ -375,7 +409,9 @@ export async function processMessage(
       "context_compacting",
       "assistant_turn",
     );
-    const result = await conversation.forceCompact();
+    const result = await conversation.forceCompact({
+      targetInputTokensOverride: slashResult.targetInputTokensOverride,
+    });
     const responseText = formatCompactResult(result);
     const assistantMsg = createAssistantMessage(responseText);
     await addMessage(
@@ -409,16 +445,11 @@ export async function processMessage(
     conversation.setSlackRuntimeContextNotice(
       options?.slackRuntimeContextNotice,
     );
-    await conversation.runAgentLoop(
-      resolvedContent,
-      messageId,
-      broadcastMessage,
-      {
-        isInteractive: options?.isInteractive ?? false,
-        isUserMessage: true,
-        ...(options?.callSite ? { callSite: options.callSite } : {}),
-      },
-    );
+    await conversation.runAgentLoop(resolvedContent, messageId, emitEvent, {
+      isInteractive: options?.isInteractive ?? false,
+      isUserMessage: true,
+      ...(options?.callSite ? { callSite: options.callSite } : {}),
+    });
   } finally {
     conversation.setSlackRuntimeContextNotice(undefined);
     if (
@@ -444,18 +475,20 @@ export async function processMessageInBackground(
   conversationId: string,
   content: string,
   attachmentIds?: string[],
-  options?: ConversationCreateOptions,
+  options?: ProcessMessageOptions,
   sourceChannel?: string,
   sourceInterface?: string,
 ): Promise<{ messageId: string }> {
+  const conversationOptions = stripPerTurnObservers(options);
   const { conversation, attachments } = await prepareConversationForMessage(
     conversationId,
     content,
     attachmentIds,
-    options,
+    conversationOptions,
     sourceChannel,
     sourceInterface,
   );
+  const emitEvent = buildEventEmitter(options?.onEvent);
 
   const requestId = crypto.randomUUID();
   const persistMetadata = options?.slackInbound
@@ -474,7 +507,7 @@ export async function processMessageInBackground(
 
   conversation.setSlackRuntimeContextNotice(options?.slackRuntimeContextNotice);
   conversation
-    .runAgentLoop(content, messageId, broadcastMessage, {
+    .runAgentLoop(content, messageId, emitEvent, {
       isInteractive: options?.isInteractive ?? false,
       isUserMessage: true,
       ...(options?.callSite ? { callSite: options.callSite } : {}),

package/src/daemon/server.ts

@@ -14,13 +14,14 @@ import { syncIdentityNameToPlatform } from "../platform/sync-identity.js";
 import { initializeProviders } from "../providers/registry.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getSigningKeyFingerprint } from "../runtime/auth/token-service.js";
+import {
+  publishAvatarChanged,
+  publishIdentityChanged,
+} from "../runtime/sync/resource-sync-events.js";
 import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { getLogger } from "../util/logger.js";
-import {
-  getAvatarImagePath,
-  getWorkspacePromptPath,
-} from "../util/platform.js";
+import { getWorkspacePromptPath } from "../util/platform.js";
 import {
   AppSourceWatcher,
   setEnsureAppSourceWatcher,
@@ -164,14 +165,7 @@ export class DaemonServer {
         ? readFileSync(identityPath, "utf-8")
         : "";
       const fields = parseIdentityFields(content);
-      broadcastMessage({
-        type: "identity_changed",
-        name: fields.name,
-        role: fields.role,
-        personality: fields.personality,
-        emoji: fields.emoji,
-        home: fields.home,
-      });
+      publishIdentityChanged(fields);
 
       // Best-effort sync of the assistant name to the platform record.
       if (fields.name) {
@@ -207,10 +201,7 @@ export class DaemonServer {
   }
 
   private broadcastAvatarUpdated(): void {
-    broadcastMessage({
-      type: "avatar_updated",
-      avatarPath: getAvatarImagePath(),
-    });
+    publishAvatarChanged();
   }
 
   /**
@@ -260,13 +251,27 @@ export class DaemonServer {
 
     this.evictor.start();
 
-    await this.cliIpc.start();
+    try {
+      await this.cliIpc.start();
+    } catch (err) {
+      log.warn(
+        { err },
+        "CLI IPC server failed to start — continuing startup with degraded CLI connectivity",
+      );
+    }
 
     // Start the skill IPC server. First-party skill processes connect to this
     // socket to access host capabilities (host.log, host.config.*,
     // host.events.*, host.registries.*). Route registry is populated by
     // subsequent PRs in the skill-isolation plan.
-    await this.skillIpc.start();
+    try {
+      await this.skillIpc.start();
+    } catch (err) {
+      log.warn(
+        { err },
+        "Skill IPC server failed to start — continuing startup with degraded skill host connectivity",
+      );
+    }
 
     this.configWatcher.start(
       () => this.evictConversationsForReload(),

package/src/daemon/shutdown-handlers.ts

@@ -23,7 +23,6 @@ export interface ShutdownDeps {
   filing: FilingService | null;
   runtimeHttp: RuntimeHttpServer | null;
   scheduler: { stop(): void };
-  feedScheduler: { stop(): void } | null;
   getMemoryWorker: () => { stop(): void } | null;
   getQdrantManager: () => QdrantManager | null;
   mcpManager: McpServerManager | null;
@@ -119,7 +118,6 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     await browserManager.closeAllPages();
     cleanupShellOutputTempFiles();
     deps.scheduler.stop();
-    deps.feedScheduler?.stop();
     deps.getMemoryWorker()?.stop();
 
     if (deps.mcpManager) {

package/src/daemon/tool-setup-types.ts

@@ -40,6 +40,15 @@ export interface ToolSetupContext extends SurfaceConversationContext {
 
   /** Turn-scoped flag: true when any tool call in the current turn received explicit user approval via interactive prompt. Cleared at turn end. */
   approvedViaPromptThisTurn?: boolean;
+  /**
+   * When true, side-effect tools must prompt for confirmation even if a
+   * trust/allow rule would auto-allow them. Set by callers without an
+   * interactive approval UI (e.g. non-guardian phone voice turns) to force
+   * a `confirmation_request` event that the caller's auto-deny / scoped-grant
+   * handler can intercept. Provides a second layer of defense against broad
+   * trust rules auto-executing side-effect tools in non-interactive contexts.
+   */
+  forcePromptSideEffects?: boolean;
   /**
    * Per-turn snapshot of the resolved inference-profile override, set by
    * `runAgentLoopImpl`. Propagated into `ToolContext.overrideProfile` so

package/src/daemon/tool-side-effects.ts

@@ -12,6 +12,7 @@ import { isAbsolute, resolve, sep } from "node:path";
 import { generateAppIcon } from "../media/app-icon-generator.js";
 import { addAppConversationId } from "../memory/app-store.js";
 import { invalidateEdgeIndex } from "../memory/v2/edge-index.js";
+import { invalidatePageIndex } from "../memory/v2/page-index.js";
 import { getConceptsDir } from "../memory/v2/page-store.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { findActiveSession } from "../runtime/channel-verification-service.js";
@@ -245,10 +246,10 @@ registerHook("bash", (_name, input, result) => {
   }
 });
 
-// Invalidate the in-memory v2 edge index when the LLM writes or edits a file
-// under `memory/concepts/`. The page-store invalidates on programmatic writes;
-// this hook covers consolidation, where the LLM edits page frontmatter through
-// the file tools rather than through `writePage`.
+// Invalidate the in-memory v2 edge index and page index when the LLM writes
+// or edits a file under `memory/concepts/`. The page-store invalidates on
+// programmatic writes; this hook covers consolidation, where the LLM edits
+// page frontmatter through the file tools rather than through `writePage`.
 function invalidateEdgeIndexIfConceptPage(
   input: Record<string, unknown>,
 ): void {
@@ -264,6 +265,7 @@ function invalidateEdgeIndexIfConceptPage(
     : conceptsRoot + sep;
   if (absPath.startsWith(rootWithSep)) {
     invalidateEdgeIndex(workspaceDir);
+    invalidatePageIndex(workspaceDir);
   }
 }
 registerHook("file_write", (_name, input) =>

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

@@ -14,6 +14,7 @@ import {
   provenanceFromTrustContext,
 } from "../memory/conversation-crud.js";
 import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
+import { backfillMessageIdOnLogs } from "../memory/llm-request-log-store.js";
 import type { WakeTarget } from "../runtime/agent-wake.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getLogger } from "../util/logger.js";
@@ -197,6 +198,16 @@ export function conversationToWakeTarget(
         JSON.stringify(message.content),
         metadata,
       );
+      if (message.role === "assistant") {
+        try {
+          backfillMessageIdOnLogs(conversation.conversationId, persisted.id);
+        } catch (err) {
+          log.warn(
+            { err, conversationId: conversation.conversationId },
+            "wake adapter: backfill messageId on LLM logs failed (non-fatal)",
+          );
+        }
+      }
       try {
         const convRow = getConversation(conversation.conversationId);
         if (convRow) {

package/src/documents/document-store.ts

@@ -5,7 +5,7 @@
  * background jobs (e.g. proactive artifact generation) can persist documents
  * without going through the HTTP layer.
  */
-import { rawRun } from "../memory/raw-query.js";
+import { rawGet, rawRun } from "../memory/raw-query.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("document-store");
@@ -83,3 +83,37 @@ export function saveDocument(params: {
     };
   }
 }
+
+/** Update persisted document content (append or replace). */
+export function updateDocumentContent(
+  surfaceId: string,
+  markdown: string,
+  mode: string,
+): void {
+  try {
+    const existing = rawGet<{ content: string }>(
+      /*sql*/ `SELECT content FROM documents WHERE surface_id = ?`,
+      surfaceId,
+    );
+    if (!existing) {
+      log.info({ surfaceId }, "No persisted document to update");
+      return;
+    }
+    const sep = mode === "append" && existing.content.length > 0 ? "\n\n" : "";
+    const newContent =
+      mode === "append" ? existing.content + sep + markdown : markdown;
+    const wordCount = newContent
+      .split(/\s+/)
+      .filter((w) => w.length > 0).length;
+    rawRun(
+      /*sql*/ `UPDATE documents SET content = ?, word_count = ?, updated_at = ? WHERE surface_id = ?`,
+      newContent,
+      wordCount,
+      Date.now(),
+      surfaceId,
+    );
+    log.info({ surfaceId, mode }, "Updated document content");
+  } catch (error) {
+    log.error({ err: error, surfaceId }, "Document content update error");
+  }
+}