@remnic/core 9.69.22 → 9.69.24

package/src/abstraction-nodes.ts

@@ -2,6 +2,7 @@ import { mkdir, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { listJsonFilesStrict, readJsonFile, withJsonStoreMutationLock, writeJsonFileAtomic } from "./json-store.js";
 import { compareDeterministicStrings, mergeSortedUniqueStrings } from "./deterministic-order.js";
+import { isNotFoundError } from "./utils/errno.js";
 import {
   assertIsoRecordedAt,
   assertSafePathSegment,
@@ -12,10 +13,6 @@ import {
   validateStringRecord,
 } from "./store-contract.js";
 
-function isNotFoundError(error: unknown): boolean {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-
 export type AbstractionNodeKind = "episode" | "topic" | "project" | "workflow" | "constraint";
 export type AbstractionLevel = "micro" | "meso" | "macro";
 

package/src/access-http-briefing.ts

@@ -0,0 +1,35 @@
+import { getOperation } from "./access-boundary.js";
+import { EngramAccessInputError, type EngramAccessService } from "./access-service.js";
+
+type JsonResponder = (status: number, payload: unknown) => void;
+
+export interface BriefingHttpOptions {
+  /** Request body already run through the namespace gate (gatedBodyNamespace). */
+  gatedBody: Record<string, unknown>;
+  service: EngramAccessService;
+  principal: string | undefined;
+  respondJson: JsonResponder;
+}
+
+/**
+ * POST /engram/v1/briefing — daily briefing over the access HTTP boundary.
+ *
+ * Dispatches the registered `briefing` boundary operation (the one the MCP
+ * tool uses) so schema validation, namespace gating, and principal
+ * propagation reach every HTTP briefing call — the same shape as the
+ * coding/delta read dispatch. Pure read: nothing persists, so no
+ * write-quota accounting. The operation result already carries both
+ * renderings (markdown + json sections) in one response, letting thin
+ * clients render without a CLI subprocess.
+ */
+export async function respondBriefingHttp(options: BriefingHttpOptions): Promise<void> {
+  const op = getOperation("briefing");
+  if (!op) {
+    throw new EngramAccessInputError("access-boundary: operation not registered: briefing");
+  }
+  const output = (await op.run(options.gatedBody, {
+    service: options.service,
+    authenticatedPrincipal: options.principal,
+  })) as { result: unknown };
+  options.respondJson(200, output.result);
+}

package/src/access-http.test.ts

@@ -810,6 +810,82 @@ test("HTTP coding-context endpoint accepts projectTag shorthand", async () => {
   }
 });
 
+test("HTTP briefing endpoint dispatches through the briefing operation", async () => {
+  const calls: unknown[] = [];
+  const service = {
+    briefing: async (request: unknown) => {
+      calls.push(request);
+      return {
+        format: "markdown",
+        window: { from: "2026-08-21", to: "2026-08-22" },
+        namespace: "team",
+        markdown: "# Briefing",
+        json: { sections: { activeThreads: [] } },
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    principal: "panel-user",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/briefing`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          since: "24h",
+          namespace: "team",
+          format: "markdown",
+          maxFollowups: 5,
+        }),
+      },
+    );
+
+    assert.equal(response.status, 200);
+    const body = (await response.json()) as { format: string; markdown: string; json: { sections: { activeThreads: unknown[] } } };
+    assert.equal(body.format, "markdown");
+    assert.equal(body.markdown, "# Briefing");
+    assert.deepEqual(body.json.sections.activeThreads, []);
+    assert.deepEqual(calls, [
+      {
+        since: "24h",
+        focus: undefined,
+        namespace: "team",
+        format: "markdown",
+        maxFollowups: 5,
+        principal: "panel-user",
+      },
+    ]);
+
+    const invalid = await fetch(
+      `http://127.0.0.1:${status.port}/engram/v1/briefing`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ format: "jsno" }),
+      },
+    );
+    assert.equal(invalid.status, 400);
+    assert.equal(((await invalid.json()) as { code: string }).code, "input_error");
+    assert.equal(calls.length, 1);
+  } finally {
+    await server.stop();
+  }
+});
+
 test("HTTP contradiction scan uses writable namespace resolver", async () => {
   const resolverCalls: Array<{
     namespace: string | undefined;

package/src/access-http.ts

@@ -49,6 +49,7 @@ import { getOperation, type OperationName } from "./access-boundary.js";
 import { authorizationProbeNamespaces, authorizationProbeRequiresPrincipalNamespace, probeOperationAuthorization } from "./access-authorization-probe.js";
 import { resolveQueryNamespaceWritablePreflight } from "./access-namespace-preflight.js";
 import { respondAccessCapabilitiesHttp } from "./access-http-lcm-compaction.js";
+import { respondBriefingHttp } from "./access-http-briefing.js";
 import { handleWhoKnowsHttpQuery } from "./who-knows.js";
 import {
   assertOperationAllowed,
@@ -994,11 +995,7 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
       // `memory_search` tool already exposes, reachable by HTTP-only clients.
       this.enforceTokenOp("memory_search"); // boundary dispatch (issue #1525)
       const operation = getOperation("memory_search");
-      if (!operation) {
-        throw new EngramAccessInputError(
-          "access-boundary: operation not registered: memory_search",
-        );
-      }
+      if (!operation) throw new EngramAccessInputError("access-boundary: operation not registered: memory_search");
       // The body `namespace` is user-controlled, so it must pass the same
       // effective-namespace allow-list gate as every other namespace-scoped
       // route (issue #1850 finding 2); the authenticated principal — never a
@@ -1946,9 +1943,7 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
         namespace: this.resolveNamespace(req, body.namespace),
       };
       const op = getOperation("memory_store");
-      if (!op) {
-        throw new EngramAccessInputError("access-boundary: operation not registered: memory_store");
-      }
+      if (!op) throw new EngramAccessInputError("access-boundary: operation not registered: memory_store");
       const output = (await op.run(envelope, {
         service: this.service,
         authenticatedPrincipal: this.resolveRequestPrincipal(req),
@@ -1980,9 +1975,7 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
         this.ensureWriteRateLimitAvailable(req);
       }
       const op = getOperation("coding_decision");
-      if (!op) {
-        throw new EngramAccessInputError("access-boundary: operation not registered: coding_decision");
-      }
+      if (!op) throw new EngramAccessInputError("access-boundary: operation not registered: coding_decision");
       const output = (await op.run(this.gatedBodyNamespace(req, body), {
         service: this.service,
         authenticatedPrincipal: this.resolveRequestPrincipal(req),
@@ -2005,9 +1998,7 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
         this.ensureWriteRateLimitAvailable(req);
       }
       const op = getOperation("coding_architecture");
-      if (!op) {
-        throw new EngramAccessInputError("access-boundary: operation not registered: coding_architecture");
-      }
+      if (!op) throw new EngramAccessInputError("access-boundary: operation not registered: coding_architecture");
       const output = (await op.run(this.gatedBodyNamespace(req, body), {
         service: this.service,
         authenticatedPrincipal: this.resolveRequestPrincipal(req),
@@ -2028,9 +2019,7 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
       // write-quota enforcement.
       const body = await this.readJsonBody(req);
       const op = getOperation("coding_delta");
-      if (!op) {
-        throw new EngramAccessInputError("access-boundary: operation not registered: coding_delta");
-      }
+      if (!op) throw new EngramAccessInputError("access-boundary: operation not registered: coding_delta");
       const output = (await op.run(this.gatedBodyNamespace(req, body), {
         service: this.service,
         authenticatedPrincipal: this.resolveRequestPrincipal(req),
@@ -2039,6 +2028,18 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
       return;
     }
 
+    // Daily briefing — pure read through the registered `briefing` boundary
+    // operation (sibling module; see access-http-briefing.ts).
+    if (req.method === "POST" && pathname === "/engram/v1/briefing") {
+      await respondBriefingHttp({
+        gatedBody: this.gatedBodyNamespace(req, await this.readJsonBody(req)),
+        service: this.service,
+        principal: this.resolveRequestPrincipal(req),
+        respondJson: (status, payload) => this.respondJson(res, status, payload),
+      });
+      return;
+    }
+
     // ── Correction Contract (issue #1580) — plan / apply / pending ─────────
     // All three routes dispatch through the boundary operations so schema
     // validation + namespace policy reach every correction path (rule 22/39).
@@ -2051,9 +2052,7 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
       this.ensureWriteRateLimitAvailable(req);
       const body = await this.readJsonBody(req);
       const op = getOperation("memory_correct_plan");
-      if (!op) {
-        throw new EngramAccessInputError("access-boundary: operation not registered: memory_correct_plan");
-      }
+      if (!op) throw new EngramAccessInputError("access-boundary: operation not registered: memory_correct_plan");
       const output = (await op.run(this.gatedBodyNamespace(req, body), {
         service: this.service,
         authenticatedPrincipal: this.resolveRequestPrincipal(req),
@@ -2067,9 +2066,7 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
       this.ensureWriteRateLimitAvailable(req);
       const body = await this.readJsonBody(req);
       const op = getOperation("memory_correct_apply");
-      if (!op) {
-        throw new EngramAccessInputError("access-boundary: operation not registered: memory_correct_apply");
-      }
+      if (!op) throw new EngramAccessInputError("access-boundary: operation not registered: memory_correct_apply");
       const output = (await op.run(this.gatedBodyNamespace(req, body), {
         service: this.service,
         authenticatedPrincipal: this.resolveRequestPrincipal(req),

package/src/access-surface-catalog.test.ts

@@ -325,6 +325,15 @@ function extractHttpRouteDispatchMap(): Map<string, Set<string>> {
       }
     }
   }
+  if (/\bawait\s+respondBriefingHttp\(/.test(source)) {
+    const briefingSource = readFileSync(
+      new URL("./access-http-briefing.ts", import.meta.url),
+      "utf-8",
+    );
+    if (briefingSource.includes('getOperation("briefing")')) {
+      routeOps.set("POST /engram/v1/briefing", new Set(["briefing"]));
+    }
+  }
   if (/\bawait\s+this\.handleReviewDeckRequest\(/.test(source)) {
     const deckSource = readFileSync(
       new URL("./review/review-deck-http-base.ts", import.meta.url),

package/src/access-surface-catalog.ts

@@ -254,6 +254,7 @@ export const HTTP_ROUTES: readonly HttpRouteEntry[] = [
   { method: "POST", pathname: "/engram/v1/coding/decisions", operation: "coding_decision" },
   { method: "POST", pathname: "/engram/v1/coding/architecture", operation: "coding_architecture" },
   { method: "POST", pathname: "/engram/v1/coding/delta", operation: "coding_delta" },
+  { method: "POST", pathname: "/engram/v1/briefing", operation: "briefing" },
   { method: "POST", pathname: "/engram/v1/suggestions", operation: "suggestion_submit" },
   { method: "GET", pathname: "/engram/v1/memories", operation: "memory_list" },
   { method: "GET", pathname: "/engram/v1/recall/timings", operation: "recall_timings" },

package/src/binary-lifecycle/backend.ts

@@ -10,6 +10,7 @@ import type { Stats } from "node:fs";
 import fsp from "node:fs/promises";
 import path from "node:path";
 import type { BinaryStorageBackendConfig } from "./types.js";
+import { isErrnoCode } from "../utils/errno.js";
 
 // ---------------------------------------------------------------------------
 // Interface
@@ -154,7 +155,7 @@ export class FilesystemBackend implements BinaryStorageBackend {
     }
 
     const realParent = await fsp.realpath(destDir).catch((err: NodeJS.ErrnoException) => {
-      if (err.code === "ENOENT") return null;
+      if (isErrnoCode(err, "ENOENT")) return null;
       throw err;
     });
     if (realParent === null) {

package/src/config.ts

@@ -50,6 +50,7 @@ import { parseDeepRecallConfig } from "./deep-recall-config.js";
 import { parseContradictionLocalizationConfig, parseContradictionScanConfig } from "./contradiction-config.js";
 import { parseGraphPathScoringConfig } from "./graph-path-scoring-config.js";
 import { parseWritePathDedupConfig } from "./dedup/novelty-gate.js";
+import { parseSemanticMergeConfig } from "./dedup/merge.js";
 import { hasLegacyConnectorEntries } from "./connectors/paths.js";
 import {
   parseQmdChunkStrategy,
@@ -3199,6 +3200,7 @@ export function parseConfig(
     // v6.0 Fact deduplication & archival
     factDeduplicationEnabled: cfg.factDeduplicationEnabled !== false,
     ...parseWritePathDedupConfig(cfg),
+    ...parseSemanticMergeConfig(cfg),
     factArchivalEnabled: cfg.factArchivalEnabled === true,
     factArchivalAgeDays:
       typeof cfg.factArchivalAgeDays === "number" ? cfg.factArchivalAgeDays : 90,

package/src/connectors/live/github.ts

@@ -63,6 +63,7 @@ import type {
   SyncIncrementalArgs,
   SyncIncrementalResult,
 } from "./framework.js";
+import { throwIfAborted } from "../../abort-error.js";
 
 // ---------------------------------------------------------------------------
 // Public constants
@@ -425,14 +426,6 @@ function pickNumericGitHubStatus(e: {
 
 const GITHUB_API_BASE = "https://api.github.com";
 
-function throwIfAborted(signal: AbortSignal | undefined): void {
-  if (signal?.aborted) {
-    const err = new Error("github: sync aborted");
-    err.name = "AbortError";
-    throw err;
-  }
-}
-
 function makeGitHubApiError(status: number, message: string): Error & { githubStatus: number } {
   const err = new Error(`github: HTTP ${status}: ${message}`) as Error & {
     githubStatus: number;
@@ -526,7 +519,7 @@ export function createGitHubConnector(
 
     async syncIncremental(args: SyncIncrementalArgs): Promise<SyncIncrementalResult> {
       const config = validateGitHubConfig(args.config);
-      throwIfAborted(args.abortSignal);
+      throwIfAborted(args.abortSignal, "github: sync aborted");
 
       // Short-circuit: nothing to do if no repos are configured.
       if (config.repos.length === 0) {
@@ -582,7 +575,7 @@ async function seedWatermarks(
   // seenIds starts empty for first-sync; nothing has been processed yet.
 
   for (const repo of config.repos) {
-    throwIfAborted(signal);
+    throwIfAborted(signal, "github: sync aborted");
 
     // Issue comments
     try {
@@ -599,7 +592,7 @@ async function seedWatermarks(
       // 404/403 → repo inaccessible, skip silently.
     }
 
-    throwIfAborted(signal);
+    throwIfAborted(signal, "github: sync aborted");
 
     // PR review comments
     try {
@@ -617,7 +610,7 @@ async function seedWatermarks(
 
     // Discussions (GraphQL not used; we use the REST search endpoint for simplicity)
     if (config.includeDiscussions) {
-      throwIfAborted(signal);
+      throwIfAborted(signal, "github: sync aborted");
       try {
         const latest = await fetchLatestTimestamp(
           fetchFn,
@@ -683,7 +676,7 @@ async function incrementalSync(
 
   for (const repo of config.repos) {
     if (totalConsumed >= MAX_ITEMS_PER_PASS) break;
-    throwIfAborted(signal);
+    throwIfAborted(signal, "github: sync aborted");
 
     // --- Issue comments ---
     {
@@ -730,7 +723,7 @@ async function incrementalSync(
     }
 
     if (totalConsumed >= MAX_ITEMS_PER_PASS) break;
-    throwIfAborted(signal);
+    throwIfAborted(signal, "github: sync aborted");
 
     // --- PR review comments ---
     {
@@ -775,7 +768,7 @@ async function incrementalSync(
 
     // --- Discussion comments (optional) ---
     if (config.includeDiscussions && totalConsumed < MAX_ITEMS_PER_PASS) {
-      throwIfAborted(signal);
+      throwIfAborted(signal, "github: sync aborted");
       const wmKey = watermarkKey(repo, "discussion");
       const since = payload.watermarks[wmKey];
       try {
@@ -922,14 +915,14 @@ async function fetchAndFilterComments(
   let nextUrl: string | undefined = firstPageUrl;
 
   while (nextUrl && consumed < remainingBudget) {
-    throwIfAborted(signal);
+    throwIfAborted(signal, "github: sync aborted");
 
     const data = await githubGet(fetchFn, token, nextUrl, signal);
     if (!Array.isArray(data)) break;
 
     for (const item of data) {
       if (consumed >= remainingBudget) break;
-      throwIfAborted(signal);
+      throwIfAborted(signal, "github: sync aborted");
 
       const comment = normalizeGitHubComment(item, kind);
       if (!comment) {

package/src/connectors/live/gmail.ts

@@ -72,6 +72,7 @@ import type {
   SyncIncrementalResult,
 } from "./framework.js";
 import { isTransientHttpError } from "./transient-errors.js";
+import { throwIfAborted } from "../../abort-error.js";
 
 // ---------------------------------------------------------------------------
 // Public constants
@@ -585,18 +586,6 @@ export function pruneSkippedIds(
   return pruned;
 }
 
-// ---------------------------------------------------------------------------
-// Cooperative cancellation
-// ---------------------------------------------------------------------------
-
-function throwIfAborted(signal: AbortSignal | undefined): void {
-  if (signal?.aborted) {
-    const err = new Error("gmail: sync aborted");
-    err.name = "AbortError";
-    throw err;
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Gmail API client helpers
 // ---------------------------------------------------------------------------
@@ -671,7 +660,7 @@ async function exchangeRefreshToken(
   config: GmailConnectorConfig,
   signal: AbortSignal | undefined,
 ): Promise<string> {
-  throwIfAborted(signal);
+  throwIfAborted(signal, "gmail: sync aborted");
   const body = new URLSearchParams({
     client_id: config.clientId,
     client_secret: config[CLIENT_SECRET_FIELD],
@@ -860,11 +849,11 @@ export function createGmailConnector(
 
     async syncIncremental(args: SyncIncrementalArgs): Promise<SyncIncrementalResult> {
       const config = validateGmailConfig(args.config);
-      throwIfAborted(args.abortSignal);
+      throwIfAborted(args.abortSignal, "gmail: sync aborted");
 
       // Exchange credentials for a short-lived access token.
       const accessToken = await exchangeRefreshToken(fetchFn, config, args.abortSignal);
-      throwIfAborted(args.abortSignal);
+      throwIfAborted(args.abortSignal, "gmail: sync aborted");
 
       // First-sync bootstrap: record "now" as the watermark and return
       // without importing anything. Mirrors Drive's getStartPageToken pattern.
@@ -981,7 +970,7 @@ async function incrementalSync(
 
   // Page through messages.list until exhausted, aborted, or per-pass cap hit.
   while (true) {
-    throwIfAborted(signal);
+    throwIfAborted(signal, "gmail: sync aborted");
 
     // Build the list URL.
     let listPath = `/users/${encodeURIComponent(config.userId)}/messages?maxResults=${LIST_PAGE_SIZE}&q=${encodeURIComponent(listQuery)}`;
@@ -1013,7 +1002,7 @@ async function incrementalSync(
         throw listErr;
       }
     }
-    throwIfAborted(signal);
+    throwIfAborted(signal, "gmail: sync aborted");
 
     const listPage = listData as {
       messages?: GmailMessageRef[];
@@ -1026,7 +1015,7 @@ async function incrementalSync(
     let capHitMidPage = false;
 
     for (const ref of messages) {
-      throwIfAborted(signal);
+      throwIfAborted(signal, "gmail: sync aborted");
 
       // Thread 2: if this id was permanently skipped in a prior pass, skip
       // it again without consuming the per-pass cap. The message is immutable
@@ -1232,7 +1221,7 @@ async function fetchMessageDocument(
   fetchedAt: string,
   signal: AbortSignal | undefined,
 ): Promise<ConnectorDocument | SkippedWithDate | "inaccessible" | null> {
-  throwIfAborted(signal);
+  throwIfAborted(signal, "gmail: sync aborted");
 
   let message: GmailMessage;
   try {

package/src/connectors/live/google-drive.ts

@@ -64,6 +64,7 @@ import type {
   SyncIncrementalResult,
 } from "./framework.js";
 import { isTransientHttpError } from "./transient-errors.js";
+import { throwIfAborted } from "../../abort-error.js";
 
 /**
  * Stable connector id. Lives in the registry under this exact string.
@@ -414,10 +415,10 @@ export function createGoogleDriveConnector(
     async syncIncremental(args: SyncIncrementalArgs): Promise<SyncIncrementalResult> {
       // Re-validate on every pass: a JS caller could mutate it between passes.
       const config = validateGoogleDriveConfig(args.config);
-      throwIfAborted(args.abortSignal);
+      throwIfAborted(args.abortSignal, "googleDrive: sync aborted");
 
       const client = await clientFactory(config);
-      throwIfAborted(args.abortSignal);
+      throwIfAborted(args.abortSignal, "googleDrive: sync aborted");
 
       // Cursor bootstrap. On the very first pass (cursor=null) we ask Drive
       // for a page token but DO NOT consume any changes — this aligns with
@@ -455,7 +456,7 @@ export function createGoogleDriveConnector(
       // Page through `changes.list` until we run out, hit the per-pass cap,
       // or get aborted.
       while (true) {
-        throwIfAborted(args.abortSignal);
+        throwIfAborted(args.abortSignal, "googleDrive: sync aborted");
         const remaining = MAX_CHANGES_PER_PASS - consumed;
         if (remaining <= 0) {
           // Hit the cap — persist whatever we have. The next pass resumes
@@ -467,7 +468,7 @@ export function createGoogleDriveConnector(
         const page = await client.listChanges({ pageToken, pageSize });
 
         for (const change of page.changes) {
-          throwIfAborted(args.abortSignal);
+          throwIfAborted(args.abortSignal, "googleDrive: sync aborted");
           consumed++;
           const decision = decideChange(change, folderScope);
           switch (decision.kind) {
@@ -538,7 +539,7 @@ async function fetchDocument(
   fetchedAt: string,
   abortSignal: AbortSignal | undefined,
 ): Promise<ConnectorDocument | null> {
-  throwIfAborted(abortSignal);
+  throwIfAborted(abortSignal, "googleDrive: sync aborted");
   const file = decision.file;
   let body: string;
   try {
@@ -581,14 +582,6 @@ async function fetchDocument(
   };
 }
 
-function throwIfAborted(signal: AbortSignal | undefined): void {
-  if (signal?.aborted) {
-    const err = new Error("googleDrive: sync aborted");
-    err.name = "AbortError";
-    throw err;
-  }
-}
-
 /**
  * Classify a per-file fetch error as "transient" (re-throw to caller so
  * the sync stops without advancing the cursor and the next poll retries)

package/src/connectors/live/notion.ts

@@ -60,6 +60,7 @@ import type {
   SyncIncrementalResult,
 } from "./framework.js";
 import { isTransientHttpError } from "./transient-errors.js";
+import { throwIfAborted } from "../../abort-error.js";
 
 // ---------------------------------------------------------------------------
 // Public constants
@@ -362,17 +363,6 @@ export function isTransientNotionError(err: unknown): boolean {
 const NOTION_BASE_URL = "https://api.notion.com/v1";
 const NOTION_API_VERSION = "2022-06-28";
 
-/**
- * Throw if aborted (cooperative cancellation).
- */
-function throwIfAborted(signal: AbortSignal | undefined): void {
-  if (signal?.aborted) {
-    const err = new Error("notion: sync aborted");
-    err.name = "AbortError";
-    throw err;
-  }
-}
-
 /**
  * Build a Notion API error with the HTTP status attached for classification.
  */
@@ -531,14 +521,14 @@ async function fetchPageText(
   signal: AbortSignal | undefined,
 ): Promise<string> {
   if (depth > MAX_BLOCK_DEPTH) return "";
-  throwIfAborted(signal);
+  throwIfAborted(signal, "notion: sync aborted");
 
   const lines: string[] = [];
   let cursor: string | undefined = undefined;
 
   // Page through block children.
   while (true) {
-    throwIfAborted(signal);
+    throwIfAborted(signal, "notion: sync aborted");
     const pathQuery = cursor
       ? `/blocks/${blockId}/children?page_size=100&start_cursor=${encodeURIComponent(cursor)}`
       : `/blocks/${blockId}/children?page_size=100`;
@@ -552,7 +542,7 @@ async function fetchPageText(
     };
 
     for (const block of page.results ?? []) {
-      throwIfAborted(signal);
+      throwIfAborted(signal, "notion: sync aborted");
       const text = extractBlockText(block);
       if (text.length > 0) lines.push(text);
 
@@ -653,7 +643,7 @@ export function createNotionConnector(
 
     async syncIncremental(args: SyncIncrementalArgs): Promise<SyncIncrementalResult> {
       const config = validateNotionConfig(args.config);
-      throwIfAborted(args.abortSignal);
+      throwIfAborted(args.abortSignal, "notion: sync aborted");
 
       // Short-circuit: if no databases are configured, there is nothing to do.
       // We still return a valid cursor so the framework has something to
@@ -719,12 +709,12 @@ async function seedWatermark(
   const databases = { ...payload.databases };
 
   for (const dbId of config.databaseIds) {
-    throwIfAborted(signal);
+    throwIfAborted(signal, "notion: sync aborted");
     let notionCursor: string | undefined = undefined;
     let latestInDb = "";
 
     while (true) {
-      throwIfAborted(signal);
+      throwIfAborted(signal, "notion: sync aborted");
       const body: Record<string, unknown> = { page_size: 100, sorts: [] };
       if (notionCursor) body.start_cursor = notionCursor;
 
@@ -784,7 +774,7 @@ async function incrementalSync(
   let totalConsumed = 0;
 
   for (const dbId of config.databaseIds) {
-    throwIfAborted(signal);
+    throwIfAborted(signal, "notion: sync aborted");
     if (totalConsumed >= MAX_PAGES_PER_PASS) break;
 
     const dbWatermark = payload.databases[dbId];
@@ -807,7 +797,7 @@ async function incrementalSync(
     let databaseFullyDrained = false;
 
     while (true) {
-      throwIfAborted(signal);
+      throwIfAborted(signal, "notion: sync aborted");
       if (totalConsumed >= MAX_PAGES_PER_PASS) break;
 
       const body: Record<string, unknown> = {
@@ -845,7 +835,7 @@ async function incrementalSync(
 
       let cutoffMidPage = false;
       for (const notionPage of pageResp.results ?? []) {
-        throwIfAborted(signal);
+        throwIfAborted(signal, "notion: sync aborted");
 
         const pageId = notionPage.id;
         const lastEdited = notionPage.last_edited_time;
@@ -970,7 +960,7 @@ async function fetchPageDocument(
   fetchedAt: string,
   signal: AbortSignal | undefined,
 ): Promise<ConnectorDocument | "too-large" | "empty" | null> {
-  throwIfAborted(signal);
+  throwIfAborted(signal, "notion: sync aborted");
 
   let text: string;
   try {