@humwick/server 0.130.2 → 0.130.4

package/src/memory-injection.ts

@@ -1,3 +1,5 @@
+import { setConfigAsync } from "./config-store-write";
+import { createCommandAsync } from "./commands-write";
 import { contextInjectUnsupported, launchContextSurvivesCompact, launchSystemPromptAppend } from "./context-injection-channel";
 // #1565 P4b — closing the auto-inject loop at the OTHER two boundaries (design §4.4).
 //
@@ -56,10 +58,10 @@ import { contextInjectUnsupported, launchContextSurvivesCompact, launchSystemPro
 import { createHash } from "node:crypto";
 import { stripRenderedAtLine } from "./context-block-rendered-at";
 import { errMessage, stringValue } from "@humwick/sdk";
-import { createCommand, findLaunchPromptCommandForAgent } from "./commands-db";
+import { findLaunchPromptCommandForAgent } from "./commands-db";
 import { emitCommandEvent } from "./command-events";
 import { REAP_INTERVAL_MS } from "./config";
-import { getConfig, setConfig } from "./config-store";
+import { getConfig } from "./config-store";
 import { findMessageByIdempotencyKey, getAgent, type MemoryIdentity } from "./db";
 import { composeMemoryPreamble, describeInstructionTruncation, describeMemoryDemotions, describeMemoryOmissions, describeUnresolvedInstructions, extractMemoryPreamble, memoryRetractionBlock, unresolvedInstructionSlugs, withMemorySupersedeNotice, type ComposedMemoryPreamble } from "./memory-preamble";
 import {
@@ -124,8 +126,8 @@ export function readMemoryInjectionState(agentId: string): MemoryInjectionState
   return getConfig<MemoryInjectionState>(MEMORY_INJECTION_NAMESPACE, agentId)?.value ?? null;
 }
 
-export function recordMemoryInjectionState(agentId: string, state: MemoryInjectionState): void {
-  setConfig(MEMORY_INJECTION_NAMESPACE, agentId, state, "memory-injection");
+export async function recordMemoryInjectionState(agentId: string, state: MemoryInjectionState): Promise<void> {
+  (await setConfigAsync(MEMORY_INJECTION_NAMESPACE, agentId, state, "memory-injection"));
 }
 
 /** #2591 — the journal gate's "what did this agent last receive" record. Same lifetime rules
@@ -144,8 +146,8 @@ export function readJournalInjectionState(agentId: string): JournalInjectionStat
   return getConfig<JournalInjectionState>(JOURNAL_INJECTION_NAMESPACE, agentId)?.value ?? null;
 }
 
-export function recordJournalInjectionState(agentId: string, state: JournalInjectionState): void {
-  setConfig(JOURNAL_INJECTION_NAMESPACE, agentId, state, "journal-injection");
+export async function recordJournalInjectionState(agentId: string, state: JournalInjectionState): Promise<void> {
+  (await setConfigAsync(JOURNAL_INJECTION_NAMESPACE, agentId, state, "journal-injection"));
 }
 
 /**
@@ -298,7 +300,7 @@ function hasEmptyBlockAccounting(seam: ResolvedMemorySeam, composed: ComposedMem
  * normal outcome (unchanged set, nothing resolvable, provider cannot inject) and is always
  * reported in the `relay-injection` event rather than being inferred from silence.
  */
-export function enqueueMemoryInjectionAfterContextCommand(command: Command, now: number = Date.now()): Command | null {
+export async function enqueueMemoryInjectionAfterContextCommand(command: Command, now: number = Date.now()): Promise<Command | null> {
   // #2291 — the boundary's status answers "did the runner CONFIRM the destructive step", not "did a
   // boundary HAPPEN". This used to read `!== "succeeded"`, which silently dropped the whole memory
   // block on every unconfirmed clear and every timed-out compact: on the live coordinator that was
@@ -335,7 +337,7 @@ export function enqueueMemoryInjectionAfterContextCommand(command: Command, now:
   if (contextInjectUnsupported(agent)) {
     // Declared and logged, never a crash: this agent keeps whatever its spawn put in the system
     // prompt and simply does not get the boundary refresh.
-    emitMemorySkip(agent, event, seam, composed, "inject-unsupported", command, now);
+    (await emitMemorySkip(agent, event, seam, composed, "inject-unsupported", command, now));
     return null;
   }
 
@@ -366,7 +368,7 @@ export function enqueueMemoryInjectionAfterContextCommand(command: Command, now:
     // empty block reached the agent when the spawn-time block is in fact still in its prompt.
     // Nothing needs the write either — the recorded hash is the block the agent LAST RECEIVED, and
     // if memory reappears the composed hash differs from it and the next boundary re-injects.
-    if (hasEmptyBlockAccounting(seam, composed)) emitMemorySkip(agent, event, seam, composed, "nothing-to-inject", command, now);
+    if (hasEmptyBlockAccounting(seam, composed)) (await emitMemorySkip(agent, event, seam, composed, "nothing-to-inject", command, now));
     if (!journal.delivers) return null;
   } else if (event === "compact" && launchContextSurvivesCompact(agent) && launchBakedMemoryHash(agent) === hash) {
     // §4.3(4): a native compact preserves a real system prompt, so a block BAKED there and still
@@ -375,7 +377,7 @@ export function enqueueMemoryInjectionAfterContextCommand(command: Command, now:
     // of this delta skip (#3698). A clear destroys the context — nothing survives it to be unchanged. #2596 —
     // this reads `launchBakedMemoryHash`, NOT the "recorded last delivery" hash: a block that only
     // ever rode a transcript message has no such proof (see that function's doc).
-    emitMemorySkip(agent, event, seam, composed, "unchanged", command, now);
+    (await emitMemorySkip(agent, event, seam, composed, "unchanged", command, now));
     if (!journal.delivers) return null;
   } else {
     memoryDelivers = true;
@@ -414,7 +416,7 @@ export function enqueueMemoryInjectionAfterContextCommand(command: Command, now:
   // keeping its own markers, notice and gate state).
   const content = [memoryContent, journal.content].filter(Boolean).join("\n\n");
   const boundaryKey = command.type === "agent.clearContext" ? { afterClearCommandId: command.id } : { afterCompactCommandId: command.id };
-  const inject = createCommand({
+  const inject = (await createCommandAsync({
     type: "agent.injectContext",
     source: "system",
     target: command.target,
@@ -448,16 +450,16 @@ export function enqueueMemoryInjectionAfterContextCommand(command: Command, now:
         }
         : {}),
     },
-  });
+  }));
   emitCommandEvent(inject, "command.requested");
-  emitRelayInjectionEvent({
+  (await emitRelayInjectionEvent({
     agentId: agent.id,
     category: "memory",
     summary: deliverySummary(event, composed, memoryDelivers, journal),
     detail: injectionDetail(agent, event, seam, composed, { commandId: inject.id, content, seamVerified, ...journalEventDetail(journal) }),
     timestamp: now,
     idempotencyKey: memoryBoundaryEventKey("delivered", agent.id, command.id),
-  });
+  }));
   return inject;
 }
 
@@ -552,8 +554,8 @@ function memoryBoundaryEventKey(outcome: "delivered" | "skipped" | "failed", age
  * swallowed silently: the operator sees the failure on the agent's timeline. The continuation
  * enqueue runs BEFORE this and is untouched by it, which is the ordering that matters.
  */
-export function settleMemoryInjectionAfterContextCommand(command: Command, now: number = Date.now()): Command | null {
-  return containedMemoryInjection(command, now).inject;
+export async function settleMemoryInjectionAfterContextCommand(command: Command, now: number = Date.now()): Promise<Command | null> {
+  return (await containedMemoryInjection(command, now)).inject;
 }
 
 /**
@@ -564,24 +566,24 @@ export function settleMemoryInjectionAfterContextCommand(command: Command, now:
  * both callers share one containment and one error report — a second try/catch in the sweep would
  * be a second place for the reporting to drift.
  */
-function containedMemoryInjection(command: Command, now: number, sweep = false): { inject: Command | null; composeFailed: boolean } {
+async function containedMemoryInjection(command: Command, now: number, sweep = false): Promise<{ inject: Command | null; composeFailed: boolean }> {
   try {
-    const inject = enqueueMemoryInjectionAfterContextCommand(command, now);
-    settleMemoryInjectionCommand(command, now);
-    settleAreaMemoryCommand(command, now);
+    const inject = (await enqueueMemoryInjectionAfterContextCommand(command, now));
+    (await settleMemoryInjectionCommand(command, now));
+    (await settleAreaMemoryCommand(command, now));
     return { inject, composeFailed: false };
   } catch (error) {
     // #2712 — the sweep runs on a fast-fail connection; a held write lock defers the boundary to the
     // next run rather than counting against its compose-failure cap.
     if (sweep && isSqliteBusyError(error)) throw error;
-    emitRelayInjectionEvent({
+    (await emitRelayInjectionEvent({
       agentId: command.target,
       category: "memory",
       summary: `memory re-injection failed to compose after ${command.type === "agent.compact" ? "compact" : command.type === "agent.clearContext" ? "clear" : command.type}: ${errMessage(error)}`,
       detail: { source: "memory-preamble", agentId: command.target, commandId: command.id, failed: true },
       timestamp: now,
       idempotencyKey: memoryBoundaryEventKey("failed", command.target, command.id),
-    });
+    }));
     return { inject: null, composeFailed: true };
   }
 }
@@ -635,12 +637,12 @@ function containedMemoryInjection(command: Command, now: number, sweep = false):
  * continuation sweep's existing policy (redundant beats wiped) applied to a larger payload, not a
  * new one; the runner's `ProviderInputQueue` serializes them rather than dropping any.
  */
-export function sweepMissedMemoryInjections(now: number = Date.now(), signal?: AbortSignal): { enqueuedCommandIds: string[]; aborted?: true } {
+export async function sweepMissedMemoryInjections(now: number = Date.now(), signal?: AbortSignal): Promise<{ enqueuedCommandIds: string[]; aborted?: true }> {
   const enqueuedCommandIds: string[] = [];
   // #1819 — one candidate is the unit; bailing between candidates leaves the rest for the next tick.
   for (const command of newestBoundaryPerAgent(now, signal)) {
     if (signal?.aborted) break;
-    sweepMemoryBoundary(command, now, enqueuedCommandIds);
+    (await sweepMemoryBoundary(command, now, enqueuedCommandIds));
   }
   return { enqueuedCommandIds, ...(signal?.aborted ? { aborted: true as const } : {}) };
 }
@@ -648,27 +650,27 @@ export function sweepMissedMemoryInjections(now: number = Date.now(), signal?: A
 /** #2712 — the job's form of {@link sweepMissedMemoryInjections}: the same units, one macrotask each. */
 async function sweepMissedMemoryInjectionsPaced(now: number, signal?: AbortSignal): Promise<{ enqueuedCommandIds: string[]; aborted?: true; moreWork?: true }> {
   const enqueuedCommandIds: string[] = [];
-  const { moreWork } = await pacedInjectionSweep(() => newestBoundaryPerAgent(now, signal), (command) => sweepMemoryBoundary(command, now, enqueuedCommandIds), signal);
+  const { moreWork } = await pacedInjectionSweep(() => newestBoundaryPerAgent(now, signal), async (command) => (await sweepMemoryBoundary(command, now, enqueuedCommandIds)), signal);
   return { enqueuedCommandIds, ...(signal?.aborted ? { aborted: true as const } : {}), ...(moreWork ? { moreWork: true as const } : {}) };
 }
 
-function sweepMemoryBoundary(command: Command, now: number, enqueuedCommandIds: string[]): void {
+async function sweepMemoryBoundary(command: Command, now: number, enqueuedCommandIds: string[]): Promise<void> {
   const { decision, attempts } = injectionAttemptDecision(command, MEMORY_INJECTION_REASON);
   if (decision === "in-flight") return;
   if (decision === "exhausted") {
-    notifyMemoryInjectionExhausted(command, attempts, now);
+    (await notifyMemoryInjectionExhausted(command, attempts, now));
     return;
   }
   if (attempts === 0 && (sweepAlreadyDecided(command) || boundaryAlreadyDecided(command))) return;
   // Through the CONTAINED enqueue: composing reaches into the store, the ownership seam and
   // cwd→project resolution, and a throw on one agent must not abort the sweep for every agent
   // behind it (the #1565 F8 rationale, one level up).
-  const { inject, composeFailed } = containedMemoryInjection(command, now, true);
+  const { inject, composeFailed } = (await containedMemoryInjection(command, now, true));
   if (inject) {
     enqueuedCommandIds.push(inject.id);
     return;
   }
-  rememberSweepDecision(command, composeFailed, now);
+  (await rememberSweepDecision(command, composeFailed, now));
 }
 
 /**
@@ -752,13 +754,13 @@ function sweepAlreadyDecided(command: Command): boolean {
   return held?.commandId === command.id && held.done;
 }
 
-function rememberSweepDecision(command: Command, composeFailed: boolean, now: number): void {
+async function rememberSweepDecision(command: Command, composeFailed: boolean, now: number): Promise<void> {
   const held = sweptBoundaryDecisions.get(command.target);
   const composeFailures = (held?.commandId === command.id ? held.composeFailures : 0) + (composeFailed ? 1 : 0);
   const done = !composeFailed || composeFailures >= MAX_INJECTION_ATTEMPTS;
   if (sweptBoundaryDecisions.size >= MAX_SWEPT_DECISIONS && !held) sweptBoundaryDecisions.clear();
   sweptBoundaryDecisions.set(command.target, { commandId: command.id, composeFailures, done });
-  if (composeFailed && done) notifyMemoryInjectionExhausted(command, composeFailures, now, "compose");
+  if (composeFailed && done) (await notifyMemoryInjectionExhausted(command, composeFailures, now, "compose"));
 }
 
 export const MEMORY_INJECTION_SWEEP_JOB = {
@@ -785,22 +787,22 @@ function boundaryAlreadyDecided(command: Command): boolean {
  *  exactly the state #2291 showed nobody can infer from silence. The two ways to spend it — the
  *  DELIVERY failing and the COMPOSITION throwing — carry different keys, or the first one reported
  *  would silence the other for the same boundary. */
-function notifyMemoryInjectionExhausted(command: Command, attempts: number, now: number, kind: "delivery" | "compose" = "delivery"): void {
+async function notifyMemoryInjectionExhausted(command: Command, attempts: number, now: number, kind: "delivery" | "compose" = "delivery"): Promise<void> {
   const idempotencyKey = `memory-injection-exhausted${kind === "compose" ? "-compose" : ""}:${command.target}:${command.id}`;
   if (findMessageByIdempotencyKey(command.target, idempotencyKey)) return;
   const event = command.type === "agent.compact" ? "compact" : "clear";
   const what = kind === "compose" ? "failed to compose" : "could not be delivered";
-  emitRelayInjectionEvent({
+  (await emitRelayInjectionEvent({
     agentId: command.target,
     category: "memory",
     summary: `memory re-injection gave up after ${attempts} attempt(s) at a ${event} boundary — it ${what}, so this agent is running without the current block`,
     detail: { source: "memory-preamble", agentId: command.target, commandId: command.id, event, attempts, exhausted: kind },
     timestamp: now,
     idempotencyKey,
-  });
+  }));
 }
 
-function emitMemorySkip(
+async function emitMemorySkip(
   agent: AgentCard,
   event: MemoryInjectionEvent,
   seam: ResolvedMemorySeam,
@@ -808,20 +810,20 @@ function emitMemorySkip(
   skipped: MemoryInjectionSkip,
   command: Command,
   now: number,
-): void {
+): Promise<void> {
   const summaries: Record<MemoryInjectionSkip, string> = {
     unchanged: `memory unchanged after ${event} — re-injection skipped (${entriesLabel(renderedCount(composed))}, ${composed.tokens}t)`,
     "inject-unsupported": `memory NOT re-injected after ${event}: provider declares context.inject:false (spawn-time block only)`,
     "nothing-to-inject": `memory resolved nothing to inject after ${event}${omissionSuffix(composed)}`,
   };
-  emitRelayInjectionEvent({
+  (await emitRelayInjectionEvent({
     agentId: agent.id,
     category: "memory",
     summary: summaries[skipped],
     detail: injectionDetail(agent, event, seam, composed, { skipped, commandId: command.id }),
     timestamp: now,
     idempotencyKey: memoryBoundaryEventKey("skipped", agent.id, command.id),
-  });
+  }));
 }
 
 /**
@@ -836,7 +838,7 @@ function emitMemorySkip(
  * the same only-on-success rule. Each side records only when ITS payload rode the command, so a
  * journal-only delivery never stamps a phantom memory hash (and vice versa).
  */
-export function settleMemoryInjectionCommand(command: Command, now: number = Date.now()): void {
+export async function settleMemoryInjectionCommand(command: Command, now: number = Date.now()): Promise<void> {
   if (command.type !== "agent.injectContext" || command.status !== "succeeded") return;
   if (command.params.reason !== MEMORY_INJECTION_REASON) return;
   const memory = command.params.memory;
@@ -844,13 +846,13 @@ export function settleMemoryInjectionCommand(command: Command, now: number = Dat
     const record = memory as Record<string, unknown>;
     const hash = typeof record.hash === "string" ? record.hash : undefined;
     if (hash !== undefined) {
-      recordMemoryInjectionState(command.target, {
+      (await recordMemoryInjectionState(command.target, {
         hash,
         tokens: typeof record.tokens === "number" ? record.tokens : 0,
         entries: typeof record.entries === "number" ? record.entries : 0,
         event: record.event === "clear" ? "clear" : "compact",
         at: now,
-      });
+      }));
     }
   }
   const journal = command.params.journal;
@@ -858,13 +860,13 @@ export function settleMemoryInjectionCommand(command: Command, now: number = Dat
     const record = journal as Record<string, unknown>;
     const hash = typeof record.hash === "string" ? record.hash : undefined;
     if (hash !== undefined) {
-      recordJournalInjectionState(command.target, {
+      (await recordJournalInjectionState(command.target, {
         hash,
         tokens: typeof record.tokens === "number" ? record.tokens : 0,
         fields: typeof record.fields === "number" ? record.fields : 0,
         event: record.event === "clear" ? "clear" : "compact",
         at: now,
-      });
+      }));
     }
   }
 }

package/src/merge-pause-maintenance.ts

@@ -1,5 +1,6 @@
+import { releaseExpiredMergePausesAsync } from "./db/runtime-tail-async";
 import { REAP_INTERVAL_MS } from "./config";
-import { releaseExpiredMergePauses } from "./db";
+
 
 export const MERGE_PAUSE_MAINTENANCE_JOB = {
   id: "merge-pause-expiration",
@@ -8,12 +9,12 @@ export const MERGE_PAUSE_MAINTENANCE_JOB = {
   description: "Release expired repo/base auto-merge pauses.",
   intervalMs: REAP_INTERVAL_MS,
   runOnStart: true,
-  // #1819 — SYNCHRONOUS, and ONE atomic statement: `releaseExpiredMergePauses` is a single UPDATE …
+  // #1819 — SYNCHRONOUS, and ONE atomic statement: `releaseExpiredMergePausesAsync` is a single UPDATE …
   // RETURNING. There is no interior checkpoint to add — splitting it would mean splitting a
   // transaction — so the pre-flight check is the whole of its cooperation. It cannot overrun a
   // deadline in any realistic fleet; if it ever does, the fix is #1809 offload, not more checks.
-  handler(context: { signal?: AbortSignal }) {
+  async handler(context: { signal?: AbortSignal }) {
     if (context.signal?.aborted) return { releasedMergePauseIds: [], aborted: true };
-    return { releasedMergePauseIds: releaseExpiredMergePauses() };
+    return { releasedMergePauseIds: (await releaseExpiredMergePausesAsync()) };
   },
 };

package/src/notification-router.ts

@@ -1,9 +1,13 @@
+import { randomUUID } from "node:crypto";
 import { isRecord } from "@humwick/sdk";
-import { notifySystemMessageWithResult } from "./notify";
-import { createActivityEvent, getAgent, getMessage } from "./db";
+import { getGateway } from "./db/gateway";
+import { emitNewMessage } from "./sse";
+import type { SendMessageResult } from "./db/messages";
+import type { AgentNoticeSlot } from "./db/terminal-events";
+import { createActivityEventAsync, getAgent, getMessage } from "./db";
 import { optedInNotificationRecipients, subscriptionDecisionFor } from "./db/notification-subscriptions";
 import { notificationEnabledFor } from "./notification-settings-store";
-import type { Message, MessageKind, NotificationRoutingExplanation, NotificationRoutingPreview, NotificationRoutingRecipientInput } from "./types";
+import type { Message, SendMessageInput, MessageKind, NotificationRoutingExplanation, NotificationRoutingPreview, NotificationRoutingRecipientInput } from "./types";
 import { DEFAULT_TTL_MS } from "./notification-types";
 import type { NotificationScope, NotificationType } from "./notification-types";
 import { isNotificationSuppressedForRole, notificationTarget, resolveAudience } from "./notification-rules";
@@ -89,17 +93,33 @@ function effectiveTtlMs(type: NotificationType, ttlMs: number | null | undefined
  * Recipients are de-duplicated and emptied of falsy entries, so emitters can pass optional ids
  * without guarding. A notification with zero resolved recipients is a no-op.
  */
-export function routeNotification(input: RouteNotificationInput): Message[] {
+export async function routeNotification(input: RouteNotificationInput): Promise<Message[]> {
+  const { inputs, preview, maxAgeSeconds } = prepareNotification(input);
+  if (!inputs.length) return [];
+  const results = await getGateway().write("notifications.route", { inputs }, { critical: true, idempotencyKey: randomUUID() }) as unknown as SendMessageResult[];
+  await emitNotificationResults(results, preview, maxAgeSeconds);
+  return results.map(result => result.message);
+}
+
+/** #1870 — the generation slot and every recipient message commit in one writer transaction. */
+export async function routeAgentNotice(slot: AgentNoticeSlot, input?: RouteNotificationInput): Promise<boolean> {
+  const prepared = input ? prepareNotification(input) : undefined;
+  const result = await getGateway().write("notifications.agentNotice", { slot, inputs: prepared?.inputs ?? [] }, { critical: true, idempotencyKey: randomUUID() }) as unknown as { created: boolean; results: SendMessageResult[] };
+  if (prepared) await emitNotificationResults(result.results, prepared.preview, prepared.maxAgeSeconds);
+  return result.created;
+}
+
+function prepareNotification(input: RouteNotificationInput) {
   const ttl = effectiveTtlMs(input.type, input.ttlMs);
   const emittedAt = input.emittedAt ?? Date.now();
 
   // Staleness guard (#451): if the triggering event is already older than its TTL, drop before
   // sending. On the normal synchronous path emittedAt ≈ now so this rarely fires, but it makes the
   // router correct for any caller that routes a delayed/replayed event.
-  if (ttl !== null && Date.now() - emittedAt > ttl) return [];
+  if (ttl !== null && Date.now() - emittedAt > ttl) return { inputs: [], preview: previewNotificationRouting({ ...input, recipients: [] }), maxAgeSeconds: null };
 
   const preview = previewNotificationRouting(input);
-  if (preview.recipients.length === 0) return [];
+
 
   // Stamp the TTL on the message so the delivery/poll path (pollMessages) enforces it for offline
   // or late-joining recipients too. An explicit `null` (never-expire) is authoritative: it suppresses
@@ -107,7 +127,8 @@ export function routeNotification(input: RouteNotificationInput): Message[] {
   // never-expire intent instead of inheriting the moderate baseline.
   const maxAgeSeconds = ttl === null ? null : Math.max(1, Math.ceil(ttl / 1000));
 
-  return preview.recipients.map((routing) => {
+  const inputs: SendMessageInput[] = [];
+  for (const routing of preview.recipients) {
     const meta = getAgent(routing.recipient)?.meta;
     const channel = meta?.kind === "channel" ? meta : undefined;
     const notificationPayload = {
@@ -115,7 +136,8 @@ export function routeNotification(input: RouteNotificationInput): Message[] {
       ...(input.message.wake === false ? { wake: false } : {}),
       routing: compactRoutingExplanation(routing),
     };
-    const result = notifySystemMessageWithResult(routing.recipient, {
+    inputs.push({
+      to: routing.recipient,
       subject: input.message.subject,
       body: input.message.body,
       payload: channel ? {
@@ -124,16 +146,21 @@ export function routeNotification(input: RouteNotificationInput): Message[] {
         event: { title: input.message.subject, body: input.message.body, notification: notificationPayload },
       } : notificationPayload,
       idempotencyKey: recipientScopedIdempotencyKey(input.message.idempotencyKey, routing.recipient),
-      kind: channel ? "channel.event" : input.message.kind,
-      from: input.message.from,
+      kind: channel ? "channel.event" : input.message.kind ?? "system",
+      from: input.message.from ?? "system",
       replyExpected: channel ? false : input.message.replyExpected,
       maxAgeSeconds,
     });
-    // The message idempotency key is the transition ledger. A retry that resolves to the existing
-    // message must not manufacture another "Notification routed" activity row (#2365).
-    if (result.created || result.updated) auditRoutingTrace(result.message, preview, maxAgeSeconds);
-    return result.message;
-  });
+  }
+  return { inputs, preview, maxAgeSeconds };
+}
+
+async function emitNotificationResults(results: SendMessageResult[], preview: NotificationRoutingPreview, maxAgeSeconds: number | null): Promise<void> {
+  for (const result of results) {
+    if (!result.created && !result.updated) continue;
+    emitNewMessage(result.message);
+    await auditRoutingTrace(result.message, preview, maxAgeSeconds);
+  }
 }
 
 function recipientScopedIdempotencyKey(key: string | undefined, recipient: string): string | undefined {
@@ -301,9 +328,9 @@ function routingExplanationFromPayload(value: unknown): NotificationRoutingExpla
   };
 }
 
-function auditRoutingTrace(message: Message, preview: NotificationRoutingPreview, maxAgeSeconds: number | null): void {
+async function auditRoutingTrace(message: Message, preview: NotificationRoutingPreview, maxAgeSeconds: number | null): Promise<void> {
   try {
-    createActivityEvent({
+    await createActivityEventAsync({
       clientId: `notification-route-${message.id}`,
       kind: "state",
       title: "Notification routed",

package/src/notify.ts

@@ -1,4 +1,4 @@
-import { sendMessageWithResult } from "./db";
+import { sendMessageWithResultAsync } from "./db/message-send";
 import { emitNewMessage } from "./sse";
 import type { Message, MessageKind } from "./types";
 
@@ -33,13 +33,13 @@ interface SystemNotifyOptions {
  * "relay tells an agent something happened" — store-ahead delivers it on next poll if the
  * recipient is offline (#234). Used by the GC sweep (maintenance) and lifecycle events (#239).
  */
-export function notifySystemMessage(to: string, opts: SystemNotifyOptions): Message {
-  return notifySystemMessageWithResult(to, opts).message;
+export async function notifySystemMessage(to: string, opts: SystemNotifyOptions): Promise<Message> {
+  return (await notifySystemMessageWithResult(to, opts)).message;
 }
 
 /** Same send seam with creation provenance for callers that own one-shot side effects/audits. */
-export function notifySystemMessageWithResult(to: string, opts: SystemNotifyOptions) {
-  const result = sendMessageWithResult({
+export async function notifySystemMessageWithResult(to: string, opts: SystemNotifyOptions) {
+  const result = await sendMessageWithResultAsync({
     from: opts.from ?? "system",
     to,
     kind: opts.kind ?? "system",

package/src/observed-reset-refresh.ts

@@ -8,14 +8,14 @@ import { settleStartupContextInjectionAfterContextCommand } from "./startup-cont
 /** #3698 — a `/clear` typed into the provider, or its auto-compaction, keeps the process and its
  *  launch-baked system prompt. Refresh identity, memory + journal and startup context through the
  *  SAME seams a commanded clear/compact settles; each is idempotent per boundary id. Never throws. */
-export function refreshContextAfterObservedReset(reset: ObservedContextReset, now: number = Date.now()): void {
+export async function refreshContextAfterObservedReset(reset: ObservedContextReset, now: number = Date.now()): Promise<void> {
   const boundary = observedResetBoundary(reset);
   try {
-    enqueueLifecycleIdentityInjectionAfterContextCommand(boundary);
+    (await enqueueLifecycleIdentityInjectionAfterContextCommand(boundary));
   } catch (error) {
     console.error(`#3698 identity refresh after observed ${reset.kind} ${reset.resetId} for ${reset.agentId} failed: ${errMessage(error)}`);
   }
   // Both contained: they report their own failures on the agent's timeline.
-  settleMemoryInjectionAfterContextCommand(boundary, now);
-  settleStartupContextInjectionAfterContextCommand(boundary, now);
+  (await settleMemoryInjectionAfterContextCommand(boundary, now));
+  (await settleStartupContextInjectionAfterContextCommand(boundary, now));
 }

package/src/operator-alarm.ts

@@ -40,11 +40,8 @@ function emitAlarm(input: OperatorAlarmInput): void {
   });
 }
 
-export function raiseOperatorAlarm(input: OperatorAlarmInput): boolean {
-  const { created } = createActivityEventWithResult(alarmEvent(input));
-  if (input.dedupeEvent && !created) return false;
-  emitAlarm(input);
-  return true;
+export async function raiseOperatorAlarm(input: OperatorAlarmInput): Promise<boolean> {
+  return raiseOperatorAlarmAsync(input);
 }
 
 /** Same as `raiseOperatorAlarm`, with the activity row written on the writer thread. */

package/src/project-ingest.ts

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { listProjectEntries, rootsForProject, retractProjectEntry, writeProjectEntry } from "./db";
+import { listProjectEntriesAsync, rootsForProjectAsync, retractProjectEntryAsync, writeProjectEntryAsync } from "./db";
 import { projectFileRoots, readProjectRootFile } from "./project-file-source";
 import type { ProjectEntry } from "./types";
 
@@ -117,7 +117,7 @@ export async function ingestClaudeMd(projectId: string, authorId: string): Promi
   // Index prior *ingested* entries by origin_ref (newest active wins). We only ever
   // read source:'ingested' here — manual/promoted are invisible to ingest by design.
   const byOrigin = new Map<string, ProjectEntry>();
-  for (const entry of listProjectEntries(projectId)) {
+  for (const entry of await listProjectEntriesAsync(projectId)) {
     if (entry.source !== "ingested" || !entry.originRef) continue;
     if (!byOrigin.has(entry.originRef)) byOrigin.set(entry.originRef, entry);
   }
@@ -128,7 +128,7 @@ export async function ingestClaudeMd(projectId: string, authorId: string): Promi
   let updated = 0;
   let unchanged = 0;
 
-  const registered = projectFileRoots(rootsForProject(projectId));
+  const registered = projectFileRoots(await rootsForProjectAsync(projectId));
   if (!registered.length && byOrigin.size) throw new Error(`no confirmed checkout host owns project ${projectId}`);
   for (const root of registered) {
     let filePath = join(root.rootPath, INGEST_FILENAME);
@@ -153,7 +153,7 @@ export async function ingestClaudeMd(projectId: string, authorId: string): Promi
           unchanged++;
           continue;
         }
-        writeProjectEntry({
+        await writeProjectEntryAsync({
           projectId,
           authorId,
           kind: "rule",
@@ -166,7 +166,7 @@ export async function ingestClaudeMd(projectId: string, authorId: string): Promi
         });
         updated++;
       } else {
-        writeProjectEntry({
+        await writeProjectEntryAsync({
           projectId,
           authorId,
           kind: "rule",
@@ -187,7 +187,7 @@ export async function ingestClaudeMd(projectId: string, authorId: string): Promi
   let retracted = 0;
   for (const [originRef, entry] of byOrigin) {
     if (seen.has(originRef)) continue;
-    retractProjectEntry(entry.id);
+    await retractProjectEntryAsync(entry.id);
     retracted++;
   }
 

package/src/project-instructions.ts

@@ -262,6 +262,13 @@ export function stripHumwickIdentitySection(value: string): string {
     .replace(/\n\n+$/, "");
 }
 
+/** The relay-owned marked sections a prompt carries on top of the startup blocks: identity, memory
+ *  and journal. The ONE strip every reader of a launched prompt uses, so a block added here (#3782:
+ *  the journal) cannot be forgotten by one of them. */
+export function stripRelayOwnedSections(value: string): string {
+  return stripJournalPreamble(stripMemoryPreamble(stripHumwickIdentitySection(value)));
+}
+
 export function composeSpawnInstructionsWithEvents(input: {
   /** Resolved fact from the selected profile's Project Instructions cell. Absent fails closed. */
   projectInstructionsEnabled?: boolean;
@@ -526,7 +533,7 @@ export function composeSpawnInstructionsWithEvents(input: {
   // strict about what it removes, so a brief that merely mentions a marker survives intact — and
   // neutralizing what survives keeps it from being read as this prompt's memory/journal block later.
   const callerSystemPromptAppend = input.callerSystemPromptAppend
-    ? neutralizeJournalMarkers(neutralizeMemoryMarkers(stripJournalPreamble(stripMemoryPreamble(stripHumwickIdentitySection(input.callerSystemPromptAppend)))))
+    ? neutralizeJournalMarkers(neutralizeMemoryMarkers(stripRelayOwnedSections(input.callerSystemPromptAppend)))
     : undefined;
   if (callerSystemPromptAppend?.trim()) {
     appendBlocks.push(callerSystemPromptAppend);