@vellumai/assistant 0.7.2 → 0.7.3

package/src/runtime/routes/inbound-message-handler.ts

@@ -15,6 +15,8 @@ import {
   createApprovalConversationGenerator,
   createApprovalCopyGenerator,
 } from "../../daemon/approval-generators.js";
+import { getDiskPressureStatus } from "../../daemon/disk-pressure-guard.js";
+import { classifyDiskPressureTurnPolicy } from "../../daemon/disk-pressure-policy.js";
 import { processMessage } from "../../daemon/process-message.js";
 import type { TrustContext } from "../../daemon/trust-context.js";
 import { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
@@ -35,6 +37,7 @@ import {
   getPendingVerificationReply,
 } from "../../memory/delivery-channels.js";
 import {
+  clearPayload,
   findMessageBySourceId,
   linkMessage,
   recordInbound,
@@ -75,6 +78,8 @@ import { tryTranscribeAudioAttachments } from "./inbound-stages/transcribe-audio
 import type { RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("runtime-http");
+const DISK_PRESSURE_REMOTE_BLOCK_REPLY =
+  "Storage is critically low, so remote messages are ignored until the guardian frees enough space. Please try again later.";
 
 // Delete-lookup retry configuration. Delete webhooks can race ahead of
 // the inbound handler's `linkMessage` call when the original message's
@@ -524,6 +529,78 @@ export async function handleChannelInbound({
     });
   }
 
+  // ── Actor role resolution ──
+  // Uses shared channel-agnostic resolution so all ingress paths classify
+  // guardian vs non-guardian actors the same way.
+  const trustCtx: TrustContext = resolveTrustContext({
+    assistantId: canonicalAssistantId,
+    sourceChannel,
+    conversationExternalId,
+    actorExternalId: rawSenderId,
+    actorUsername: body.actorUsername,
+    actorDisplayName: body.actorDisplayName,
+  });
+
+  const diskPressureDecision = classifyDiskPressureTurnPolicy(
+    getDiskPressureStatus(),
+    {
+      sourceChannel,
+      sourceInterface,
+      trustContext: {
+        sourceChannel: trustCtx.sourceChannel,
+        trustClass: trustCtx.trustClass,
+      },
+    },
+  );
+  if (diskPressureDecision.action === "block") {
+    if (!result.duplicate) {
+      clearPayload(result.eventId);
+      markProcessed(result.eventId);
+    }
+    log.info(
+      {
+        conversationId: result.conversationId,
+        eventId: result.eventId,
+        duplicate: result.duplicate,
+        reason: diskPressureDecision.reason,
+        trustClass: trustCtx.trustClass,
+      },
+      "Channel inbound blocked during disk pressure cleanup mode",
+    );
+
+    if (replyCallbackUrl && !result.duplicate) {
+      const replyPayload: Parameters<typeof deliverChannelReply>[1] = {
+        chatId: conversationExternalId,
+        text: DISK_PRESSURE_REMOTE_BLOCK_REPLY,
+        assistantId: canonicalAssistantId,
+      };
+      if (sourceChannel === "slack" && (canonicalSenderId ?? rawSenderId)) {
+        replyPayload.ephemeral = true;
+        replyPayload.user = (canonicalSenderId ?? rawSenderId)!;
+      }
+      try {
+        await deliverChannelReply(replyCallbackUrl, replyPayload);
+      } catch (err) {
+        log.warn(
+          {
+            err,
+            conversationId: result.conversationId,
+            eventId: result.eventId,
+          },
+          "Failed to deliver disk pressure block reply",
+        );
+      }
+    }
+
+    return {
+      accepted: true,
+      duplicate: result.duplicate,
+      eventId: result.eventId,
+      diskPressure: "blocked",
+      reason: diskPressureDecision.reason,
+    };
+  }
+
   // ── Slack reaction handling ──
   // Reactions arrive as regular `SlackInboundEvent`s with `callbackData`
   // prefixed `reaction:` (added) or `reaction_removed:` (removed).
@@ -735,18 +812,6 @@ export async function handleChannelInbound({
   // which handles request code matching, callback parsing, and NL classification
   // against canonical_guardian_requests.
 
-  // ── Actor role resolution ──
-  // Uses shared channel-agnostic resolution so all ingress paths classify
-  // guardian vs non-guardian actors the same way.
-  const trustCtx: TrustContext = resolveTrustContext({
-    assistantId: canonicalAssistantId,
-    sourceChannel,
-    conversationExternalId,
-    actorExternalId: rawSenderId,
-    actorUsername: body.actorUsername,
-    actorDisplayName: body.actorDisplayName,
-  });
-
   // ── Canonical guardian reply router ──
   const guardianReplyResult = await handleGuardianReplyIntercept({
     isDuplicate: result.duplicate,

package/src/runtime/routes/inbound-stages/guardian-reply-intercept.ts

@@ -174,6 +174,9 @@ export async function handleGuardianReplyIntercept(
         eventId,
         canonicalRouter: routerResult.type,
         requestId: routerResult.requestId,
+        ...(routerResult.activatedContact
+          ? { activatedContact: routerResult.activatedContact }
+          : {}),
       }),
       skipApprovalInterception: false,
     };

package/src/runtime/routes/index.ts

@@ -37,9 +37,11 @@ import { ROUTES as CONVERSATION_QUERY_ROUTES } from "./conversation-query-routes
 import { ROUTES as CONVERSATION_MESSAGE_ROUTES } from "./conversation-routes.js";
 import { ROUTES as CONVERSATION_STARTER_ROUTES } from "./conversation-starter-routes.js";
 import { ROUTES as CREDENTIAL_PROMPT_ROUTES } from "./credential-prompt-routes.js";
+import { ROUTES as DEBUG_BASH_ROUTES } from "./debug-bash-routes.js";
 import { ROUTES as DEBUG_ROUTES } from "./debug-routes.js";
 import { ROUTES as DEFER_ROUTES } from "./defer-routes.js";
 import { ROUTES as DIAGNOSTICS_ROUTES } from "./diagnostics-routes.js";
+import { ROUTES as DISK_PRESSURE_ROUTES } from "./disk-pressure-routes.js";
 import { ROUTES as DOCUMENT_ROUTES } from "./documents-routes.js";
 import { ROUTES as EVENTS_ROUTES } from "./events-routes.js";
 import { ROUTES as FILING_ROUTES } from "./filing-routes.js";
@@ -74,6 +76,7 @@ import { ROUTES as MIGRATION_ROLLBACK_ROUTES } from "./migration-rollback-routes
 import { ROUTES as MIGRATION_ROUTES } from "./migration-routes.js";
 import { ROUTES as NOTIFICATION_ROUTES } from "./notification-routes.js";
 import { ROUTES as OAUTH_APPS_ROUTES } from "./oauth-apps.js";
+import { ROUTES as OAUTH_CONNECT_ROUTES } from "./oauth-connect-routes.js";
 import { ROUTES as OAUTH_PROVIDERS_ROUTES } from "./oauth-providers.js";
 import { ROUTES as PLAYGROUND_ROUTES } from "./playground/index.js";
 import { ROUTES as PROFILER_ROUTES } from "./profiler-routes.js";
@@ -137,8 +140,10 @@ export const ROUTES: RouteDefinition[] = [
   ...DEFER_ROUTES,
   ...CONVERSATION_QUERY_ROUTES,
   ...CONVERSATION_STARTER_ROUTES,
+  ...DEBUG_BASH_ROUTES,
   ...DEBUG_ROUTES,
   ...DIAGNOSTICS_ROUTES,
+  ...DISK_PRESSURE_ROUTES,
   ...DOCUMENT_ROUTES,
   ...EVENTS_ROUTES,
   ...FILING_ROUTES,
@@ -159,6 +164,7 @@ export const ROUTES: RouteDefinition[] = [
   ...INTERFACE_ROUTES,
   ...INTERNAL_OAUTH_ROUTES,
   ...MCP_AUTH_ROUTES,
+  ...OAUTH_CONNECT_ROUTES,
   ...INTERNAL_TWILIO_ROUTES,
   ...LOG_EXPORT_ROUTES,
   ...LLM_CALL_SITES_ROUTES,

package/src/runtime/routes/memory-item-routes.test.ts

@@ -6,6 +6,13 @@
  */
 import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../../config/assistant-feature-flags.js";
+
+// This test exercises v1 memory CRUD routes. The `memory-v2-enabled` flag
+// (registry default `true`) flips memory routing to v2 — disable it here so
+// the v1 paths under test stay active.
+_setOverridesForTesting({ "memory-v2-enabled": false });
+
 mock.module("../../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -68,11 +75,7 @@ import { eq } from "drizzle-orm";
 import { getDb } from "../../memory/db-connection.js";
 import { initializeDb } from "../../memory/db-init.js";
 import { memoryGraphNodes, memoryJobs } from "../../memory/schema.js";
-import {
-  BadRequestError,
-  ConflictError,
-  NotFoundError,
-} from "./errors.js";
+import { BadRequestError, ConflictError, NotFoundError } from "./errors.js";
 import { ROUTES } from "./memory-item-routes.js";
 import type { RouteDefinition } from "./types.js";
 
@@ -269,7 +272,9 @@ describe("Memory Item Routes", () => {
         content: "s2\nst2",
       });
 
-      const res = await callHandler(route, { queryParams: { kind: "semantic" } });
+      const res = await callHandler(route, {
+        queryParams: { kind: "semantic" },
+      });
       const body = (await res.json()) as {
         items: Array<{ id: string }>;
         total: number;
@@ -319,7 +324,9 @@ describe("Memory Item Routes", () => {
         lastAccessed: 3000,
       });
 
-      const res = await callHandler(route, { queryParams: { limit: "1", offset: "1" } });
+      const res = await callHandler(route, {
+        queryParams: { limit: "1", offset: "1" },
+      });
       const body = (await res.json()) as {
         items: Array<{ id: string }>;
         total: number;
@@ -344,7 +351,9 @@ describe("Memory Item Routes", () => {
         created: 1000,
       });
 
-      const res = await callHandler(route, { queryParams: { sort: "firstSeenAt", order: "asc" } });
+      const res = await callHandler(route, {
+        queryParams: { sort: "firstSeenAt", order: "asc" },
+      });
       const body = (await res.json()) as {
         items: Array<{ id: string }>;
       };
@@ -366,7 +375,9 @@ describe("Memory Item Routes", () => {
         significance: 0.9,
       });
 
-      const res = await callHandler(route, { queryParams: { sort: "importance", order: "desc" } });
+      const res = await callHandler(route, {
+        queryParams: { sort: "importance", order: "desc" },
+      });
       const body = (await res.json()) as {
         items: Array<{ id: string }>;
       };
@@ -418,7 +429,9 @@ describe("Memory Item Routes", () => {
         },
       ];
 
-      const res = await callHandler(route, { queryParams: { search: "alice" } });
+      const res = await callHandler(route, {
+        queryParams: { search: "alice" },
+      });
       const body = (await res.json()) as {
         items: Array<{ id: string }>;
         total: number;
@@ -503,7 +516,9 @@ describe("Memory Item Routes", () => {
       ];
 
       // Request page 2 (offset=1, limit=1)
-      const res = await callHandler(route, { queryParams: { search: "item", limit: "1", offset: "1" } });
+      const res = await callHandler(route, {
+        queryParams: { search: "item", limit: "1", offset: "1" },
+      });
       const body = (await res.json()) as {
         items: Array<{ id: string }>;
         total: number;
@@ -563,7 +578,10 @@ describe("Memory Item Routes", () => {
         content: "dark mode\nPrefers dark mode",
       });
 
-      const res = await callHandler(route, { queryParams: {}, pathParams: { id: "i1" } });
+      const res = await callHandler(route, {
+        queryParams: {},
+        pathParams: { id: "i1" },
+      });
       expect(res.status).toBe(200);
       const body = (await res.json()) as {
         item: { id: string; subject: string };
@@ -573,7 +591,10 @@ describe("Memory Item Routes", () => {
     });
 
     test("returns 404 for non-existent item", async () => {
-      const res = await callHandler(route, { queryParams: {}, pathParams: { id: "nonexistent" } });
+      const res = await callHandler(route, {
+        queryParams: {},
+        pathParams: { id: "nonexistent" },
+      });
       expect(res.status).toBe(404);
     });
 
@@ -584,7 +605,10 @@ describe("Memory Item Routes", () => {
         content: "some content\nsome statement",
       });
 
-      const res = await callHandler(route, { queryParams: {}, pathParams: { id: "i1" } });
+      const res = await callHandler(route, {
+        queryParams: {},
+        pathParams: { id: "i1" },
+      });
       const body = (await res.json()) as {
         item: { supersedes: unknown; supersededBy: unknown };
       };
@@ -862,7 +886,9 @@ describe("Memory Item Routes", () => {
     });
 
     test("returns 404 for non-existent item", async () => {
-      const res = await callHandler(route, { pathParams: { id: "nonexistent" } });
+      const res = await callHandler(route, {
+        pathParams: { id: "nonexistent" },
+      });
       expect(res.status).toBe(404);
     });
 

package/src/runtime/routes/memory-v2-routes.ts

@@ -22,6 +22,10 @@ import {
   enqueueMemoryJob,
   type MemoryJobType,
 } from "../../memory/jobs-store.js";
+import {
+  type ConceptFrequencyResponse,
+  getConceptFrequencySummary,
+} from "../../memory/memory-v2-concept-frequency.js";
 import {
   getEdgeIndex,
   totalEdgeCount,
@@ -459,6 +463,24 @@ async function handleExplainSimilarity({
   };
 }
 
+// ── Concept injection frequency (debug-only) ────────────────────────────
+
+const MemoryV2ConceptFrequencyParams = z
+  .object({
+    conversationId: z.string().min(1).optional(),
+    sinceMs: z.number().int().nonnegative().optional(),
+  })
+  .strict();
+
+async function handleConceptFrequency({
+  body = {},
+}: RouteHandlerArgs): Promise<ConceptFrequencyResponse> {
+  const { conversationId, sinceMs } =
+    MemoryV2ConceptFrequencyParams.parse(body);
+  const workspaceDir = getWorkspaceDir();
+  return getConceptFrequencySummary(workspaceDir, { conversationId, sinceMs });
+}
+
 // ── Fit anisotropy calibration ──────────────────────────────────────────
 
 const MemoryV2FitAnisotropyParams = z
@@ -614,6 +636,17 @@ export const ROUTES: RouteDefinition[] = [
     tags: ["memory"],
     requestBody: MemoryV2RebuildCorpusStatsParams,
   },
+  {
+    operationId: "memory_v2_concept_frequency",
+    method: "POST",
+    endpoint: "memory/v2/concept-frequency",
+    handler: handleConceptFrequency,
+    summary: "Aggregate per-concept injection frequency from activation logs",
+    description:
+      "Debug-only. Aggregates the existing memory_v2_activation_logs table by (slug, status) and cross-references on-disk concept pages so an operator can see which concepts get injected often, which get scored but rejected, and which on-disk pages never even surface as candidates. Optional filters: conversationId narrows to a single conversation; sinceMs restricts to logs created at-or-after the given epoch ms timestamp.",
+    tags: ["memory"],
+    requestBody: MemoryV2ConceptFrequencyParams,
+  },
   {
     operationId: "memory_v2_fit_anisotropy",
     method: "POST",

package/src/runtime/routes/oauth-connect-routes.ts

@@ -0,0 +1,153 @@
+/**
+ * Internal routes for daemon-owned OAuth connect flows (CLI gateway transport fix).
+ *
+ * POST internal/oauth/connect/start   — starts the flow in the daemon, returns auth URL
+ * GET  internal/oauth/connect/status/:state — polls current flow status
+ */
+
+import { z } from "zod";
+
+import { orchestrateOAuthConnect } from "../../oauth/connect-orchestrator.js";
+import {
+  getOAuthConnectState,
+  setOAuthConnectComplete,
+  setOAuthConnectError,
+  setOAuthConnectPending,
+} from "../../oauth/oauth-connect-state.js";
+import { getLogger } from "../../util/logger.js";
+import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
+import type { RouteDefinition } from "./types.js";
+
+const log = getLogger("oauth-connect-routes");
+
+async function handleOAuthConnectStart({
+  body,
+}: {
+  body?: Record<string, unknown>;
+}): Promise<{ auth_url: string; state: string }> {
+  const {
+    service,
+    clientId,
+    clientSecret,
+    callbackTransport,
+    requestedScopes,
+  } = (body ?? {}) as {
+    service: string;
+    clientId: string;
+    clientSecret?: string;
+    callbackTransport?: string;
+    requestedScopes?: string[];
+  };
+
+  if (!service) throw new BadRequestError("service is required");
+  if (!clientId) throw new BadRequestError("clientId is required");
+  if (callbackTransport !== "loopback" && callbackTransport !== "gateway") {
+    throw new BadRequestError(
+      'callbackTransport must be "loopback" or "gateway"',
+    );
+  }
+
+  // Capture resolvedState separately so the onDeferredComplete closure can
+  // reference it without a reference-before-assignment risk (the fire-and-forget
+  // tail only fires after the await resolves, by which point resolvedState is set).
+  // eslint-disable-next-line prefer-const -- intentional forward-declared binding
+  let resolvedState: string | undefined;
+
+  let result: Awaited<ReturnType<typeof orchestrateOAuthConnect>>;
+  try {
+    result = await orchestrateOAuthConnect({
+      service,
+      clientId,
+      clientSecret,
+      callbackTransport,
+      ...(requestedScopes ? { requestedScopes } : {}),
+      isInteractive: false,
+      onDeferredComplete: (r) => {
+        if (!resolvedState) return;
+        if (r.success) {
+          setOAuthConnectComplete(resolvedState, r.service, r.accountInfo, r.grantedScopes);
+        } else {
+          setOAuthConnectError(resolvedState, r.service, r.error ?? "OAuth connect failed");
+        }
+      },
+    });
+  } catch (err) {
+    throw new InternalError(err instanceof Error ? err.message : String(err));
+  }
+
+  if (!result.success) {
+    throw new InternalError(result.error);
+  }
+  if (!result.deferred) {
+    throw new InternalError("Orchestrator returned non-deferred result");
+  }
+
+  resolvedState = result.state;
+  setOAuthConnectPending(result.state, service);
+  log.info({ state: result.state, service }, "oauth connect flow started");
+  return { auth_url: result.authorizeUrl, state: result.state };
+}
+
+function handleOAuthConnectStatus({
+  pathParams,
+}: {
+  pathParams?: Record<string, string>;
+}): {
+  status: "pending" | "complete" | "error";
+  service: string;
+  account_info?: string;
+  granted_scopes?: string[];
+  error?: string;
+} {
+  const { state } = pathParams as { state: string };
+  const flowState = getOAuthConnectState(state);
+
+  if (flowState === null) {
+    throw new NotFoundError(`No active OAuth connect flow for state "${state}"`);
+  }
+
+  if (flowState.status === "pending") return { status: "pending", service: flowState.service };
+  if (flowState.status === "complete") {
+    return {
+      status: "complete",
+      service: flowState.service,
+      ...(flowState.accountInfo ? { account_info: flowState.accountInfo } : {}),
+      ...(flowState.grantedScopes ? { granted_scopes: flowState.grantedScopes } : {}),
+    };
+  }
+  return { status: "error", service: flowState.service, error: flowState.error };
+}
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "internal_oauth_connect_start",
+    endpoint: "internal/oauth/connect/start",
+    method: "POST",
+    summary: "Start daemon-owned OAuth connect flow",
+    description:
+      "Starts an OAuth connect flow in the daemon and returns the authorization URL for the CLI to open in the browser.",
+    tags: ["internal"],
+    requestBody: z.object({
+      service: z.string(),
+      clientId: z.string(),
+      clientSecret: z.string().optional(),
+      callbackTransport: z.enum(["loopback", "gateway"]),
+      requestedScopes: z.array(z.string()).optional(),
+    }),
+    handler: handleOAuthConnectStart,
+  },
+  {
+    operationId: "internal_oauth_connect_status",
+    endpoint: "internal/oauth/connect/status/:state",
+    method: "GET",
+    summary: "Poll daemon OAuth connect flow status",
+    description:
+      "Returns the current status of an in-flight daemon-owned OAuth connect flow (pending/complete/error).",
+    tags: ["internal"],
+    pathParams: [{ name: "state" }],
+    additionalResponses: {
+      "404": { description: "No active OAuth connect flow for the given state token" },
+    },
+    handler: handleOAuthConnectStatus,
+  },
+];

package/src/runtime/verification-outbound-actions.ts

@@ -79,7 +79,7 @@ export function normalizeTelegramDestination(destination: string): string {
 // Input / output types
 // ---------------------------------------------------------------------------
 
-export interface StartOutboundParams {
+interface StartOutboundParams {
   channel: ChannelId;
   destination?: string;
   rebind?: boolean;
@@ -87,13 +87,13 @@ export interface StartOutboundParams {
   originConversationId?: string;
 }
 
-export interface ResendOutboundParams {
+interface ResendOutboundParams {
   channel: ChannelId;
   /** Origin conversation ID so completion/failure pointers can route back on resend. */
   originConversationId?: string;
 }
 
-export interface CancelOutboundParams {
+interface CancelOutboundParams {
   channel: ChannelId;
 }
 
@@ -102,7 +102,7 @@ export interface CancelOutboundParams {
  * Maps 1:1 with the fields in ChannelVerificationSessionResponse minus the
  * `type` discriminant.
  */
-export interface OutboundActionResult {
+interface OutboundActionResult {
   success: boolean;
   error?: string;
   message?: string;

package/src/schedule/run-script.ts

@@ -38,21 +38,53 @@ export async function runScript(
     env: buildSanitizedEnv(),
   });
 
-  // Race process completion against a timeout
+  // Start consuming streams immediately so buffered output is available even on timeout.
+  // When the process is killed the pipe fds close and these promises resolve on their own.
+  const stdoutPromise = new Response(proc.stdout).text();
+  const stderrPromise = new Response(proc.stderr).text();
+
+  let timedOut = false;
+
   const timeoutPromise = new Promise<never>((_, reject) => {
     const timer = setTimeout(() => {
+      timedOut = true;
       proc.kill("SIGKILL");
       reject(new Error(`Script timed out after ${timeoutMs}ms`));
     }, timeoutMs);
     timer.unref();
-    // Clean up timer if process finishes first
     proc.exited.then(() => clearTimeout(timer));
   });
 
-  const exitCode = await Promise.race([proc.exited, timeoutPromise]);
+  /** How long to wait for pipes to drain after SIGKILL before giving up. */
+  const DRAIN_TIMEOUT_MS = 5_000;
+
+  let exitCode: number;
+  try {
+    exitCode = await Promise.race([proc.exited, timeoutPromise]);
+  } catch (err) {
+    if (!timedOut) throw err;
+    // Collect whatever the process wrote before it was killed.
+    // Race each stream against a short drain window — if a background child
+    // process inherited the pipe fd, the stream would otherwise never reach
+    // EOF and block the scheduler tick indefinitely.
+    const empty = (ms: number): Promise<string> =>
+      new Promise((resolve) => setTimeout(() => resolve(""), ms));
+    const [stdoutStr, stderrStr] = await Promise.all([
+      Promise.race([stdoutPromise, empty(DRAIN_TIMEOUT_MS)]),
+      Promise.race([stderrPromise, empty(DRAIN_TIMEOUT_MS)]),
+    ]);
+    const stdout = truncate(stdoutStr);
+    const timeoutMsg = `Script timed out after ${timeoutMs}ms`;
+    const stderr = truncate(stderrStr ? `${timeoutMsg}\n${stderrStr}` : timeoutMsg);
+    log.info(
+      { command, timedOut: true, stdoutLen: stdout.length },
+      "Script timed out",
+    );
+    return { exitCode: 124, stdout, stderr };
+  }
 
-  const stdout = truncate(await new Response(proc.stdout).text());
-  const stderr = truncate(await new Response(proc.stderr).text());
+  const stdout = truncate(await stdoutPromise);
+  const stderr = truncate(await stderrPromise);
 
   log.info(
     { command, exitCode, stdoutLen: stdout.length, stderrLen: stderr.length },

package/src/schedule/scheduler.ts

@@ -1,3 +1,8 @@
+import {
+  checkDiskPressureBackgroundGate,
+  diskPressureBackgroundSkipLogFields,
+  shouldLogDiskPressureBackgroundSkip,
+} from "../daemon/disk-pressure-background-gate.js";
 import { emitFeedEvent } from "../home/emit-feed-event.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { getConversation } from "../memory/conversation-crud.js";
@@ -129,7 +134,7 @@ export function startScheduler(
   };
 }
 
-async function runScheduleOnce(
+export async function runScheduleOnce(
   processMessage: ScheduleMessageProcessor,
   notifyScheduleOneShot: ScheduleNotifyModeNotifier,
   watcherNotifier?: WatcherNotifier,
@@ -139,6 +144,20 @@ async function runScheduleOnce(
   const now = Date.now();
   let processed = 0;
 
+  const diskPressureGate = checkDiskPressureBackgroundGate("background-work");
+  if (diskPressureGate.action === "skip") {
+    if (shouldLogDiskPressureBackgroundSkip("scheduler")) {
+      log.warn(
+        {
+          source: "schedule",
+          ...diskPressureBackgroundSkipLogFields(diskPressureGate),
+        },
+        "Schedule tick skipped during disk pressure cleanup mode",
+      );
+    }
+    return 0;
+  }
+
   // ── Schedules (recurring cron/RRULE + one-shot) ─────────────────────
   const jobs = claimDueSchedules(now);
   for (const job of jobs) {

package/src/security/encrypted-store.ts

@@ -108,6 +108,8 @@ function getStoreKeyPath(): string {
   );
 }
 
+
+
 /**
  * Read the store.key file. Returns the raw 32-byte key buffer, or null
  * if the file is missing, wrong size, or unreadable.