@remnic/core 9.15.3 → 9.16.0

package/src/config.ts

@@ -51,6 +51,7 @@ import {
   resolveNamespaceCatalogEnabled,
 } from "./emit-legacy-tools.js";
 import { parseWearablesConfig } from "./wearables/config.js";
+import { parseActivityConfig } from "./activity/config.js";
 import { parseProvenanceConfig } from "./provenance.js";
 import { parseBoundedJsonlStateConfig } from "./bounded-jsonl-state.js";
 import { parseCodingKnowledgeConfig } from "./coding/coding-knowledge-config.js";
@@ -1172,6 +1173,7 @@ export function parseConfig(
 
   // Wearable transcript ingestion (Limitless / Bee / Omi) — delegated to the wearables module.
   const wearables = parseWearablesConfig(cfg.wearables);
+  const activity = parseActivityConfig(cfg.activity);
 
   const provenance = parseProvenanceConfig(cfg.provenance);
   // Coding-agent project/branch scoping (issue #569)
@@ -2335,6 +2337,7 @@ export function parseConfig(
     dreamsPhases,
     procedural,
     wearables,
+    activity,
     provenance,
     // At-rest encryption (issue #690 PR 3/4)
     // coerceBool handles CLI string inputs: `--config secureStoreEnabled=true`

package/src/orchestration/maintenance.test.ts

@@ -162,7 +162,7 @@ test("runQmdMaintenance updates and embeds cataloged dynamic namespaces (NGnei)"
     assert.equal(embedCalls.length, 1, "QMD embed must batch all selected namespaces into one router call");
     assert.deepEqual(new Set(embedCalls[0]), new Set(["default", "shared", dynamicNamespace]));
   } finally {
-    scheduler.dispose();
+    await scheduler.dispose();
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
@@ -218,7 +218,7 @@ test("runQmdMaintenance tracks namespace embed cadence across budget rotation",
       "a global embed timestamp must not suppress embeddings for newly budgeted namespaces",
     );
   } finally {
-    scheduler.dispose();
+    await scheduler.dispose();
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
@@ -285,7 +285,7 @@ test("runQmdMaintenance skips cataloged dynamic namespaces whose live root is un
       "cataloged dynamic namespaces are skipped when the live router root differs from the catalog-sanitized root",
     );
   } finally {
-    scheduler.dispose();
+    await scheduler.dispose();
     await rm(memoryDir, { recursive: true, force: true });
     await rm(outsideDir, { recursive: true, force: true });
   }
@@ -337,7 +337,7 @@ test("runQmdMaintenance treats zero namespace updates as failed maintenance", as
     assert.equal(markMaintenanceCalls, 0);
     assert.equal(embedCalls, 0);
   } finally {
-    scheduler.dispose();
+    await scheduler.dispose();
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
@@ -393,7 +393,7 @@ test("runQmdMaintenance treats partial namespace update eligibility as failed ma
     assert.equal(markMaintenanceCalls, 0);
     assert.equal(embedCalls, 0);
   } finally {
-    scheduler.dispose();
+    await scheduler.dispose();
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
@@ -442,7 +442,7 @@ test("runQmdMaintenance treats namespace embed errors as failed maintenance", as
     );
     assert.equal(markMaintenanceCalls, 0);
   } finally {
-    scheduler.dispose();
+    await scheduler.dispose();
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
@@ -515,7 +515,7 @@ test("runQmdMaintenance records QMD min-interval throttles as skipped maintenanc
     assert.equal(markMaintenanceCalls, 0);
     assert.equal(embedCalls, 0);
   } finally {
-    scheduler.dispose();
+    await scheduler.dispose();
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
@@ -578,7 +578,7 @@ test("runQmdMaintenance still embeds when due update is throttled", async () =>
     );
     assert.equal(markMaintenanceCalls, 0);
   } finally {
-    scheduler.dispose();
+    await scheduler.dispose();
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
@@ -637,7 +637,7 @@ test("runQmdMaintenance treats strict namespace update errors as failed maintena
     assert.equal(markMaintenanceCalls, 0);
     assert.equal(embedCalls, 0);
   } finally {
-    scheduler.dispose();
+    await scheduler.dispose();
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
@@ -682,7 +682,7 @@ test("runQmdMaintenance falls back to configured namespaces when the catalog is
       "a disabled catalog covers exactly the configured set",
     );
   } finally {
-    scheduler.dispose();
+    await scheduler.dispose();
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
@@ -747,7 +747,7 @@ test("MaintenanceScheduler reads a runtime-swapped qmd backend via getQmd (regre
       "after the swap to NoopSearchBackend, requestQmdMaintenance must short-circuit (isAvailable===false) and never touch the disposed backend",
     );
   } finally {
-    scheduler.dispose();
+    await scheduler.dispose();
   }
 });
 
@@ -825,7 +825,7 @@ test("auto-compaction shrinks an oversized ledger and writes a verbatim backup",
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
 
     const afterSize = (await stat(ledgerPath)).size;
@@ -897,7 +897,7 @@ alpha
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
 
     const rebuilt = (await readFile(ledgerPath, "utf-8"))
@@ -934,7 +934,7 @@ test("auto-compaction is disabled when memoryLifecycleLedgerCompactBytes is 0",
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
     assert.equal(await readFile(ledgerPath, "utf-8"), before, "disabled: ledger untouched");
     await assert.rejects(() => readdir(path.join(memoryDir, "archive", "memory-lifecycle-ledger")));
@@ -967,7 +967,7 @@ test("auto-compaction min-interval throttle prevents a second run within the win
       assert.equal((await stat(ledgerPath)).size, regrownSize, "throttled: ledger not recompacted");
       assert.ok(regrownSize > compactedSize);
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
@@ -988,7 +988,7 @@ test("auto-compaction is a no-op when the ledger is below the threshold", async
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
     assert.equal(await readFile(ledgerPath, "utf-8"), before, "under threshold: ledger untouched");
   } finally {
@@ -1064,7 +1064,7 @@ test("auto-compaction singleflight: two requests racing through the over-cap pro
       assert.equal(stamps.length, 1, "only one compaction backup exists");
       assert.ok((await stat(ledgerPath)).size < 4096, "ledger was compacted once");
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
@@ -1120,7 +1120,7 @@ test("auto-compaction leaves the throttle un-advanced after a failed run so it r
         "still-eligible retry compacts once the failure clears",
       );
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
@@ -1147,7 +1147,7 @@ test("auto-compaction rewrites the ledger encrypted at rest under a secure store
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
     // The rewritten ledger is encrypted at rest and smaller than the plaintext
     // original, and decrypts back to the rebuilt events via the same key.
@@ -1215,7 +1215,7 @@ test("auto-compaction re-encrypts an ENCRYPTED ledger's backup for the archive p
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
 
     assert.ok(isEncryptedFile(await readFile(ledgerPath)), "compacted ledger stays encrypted at rest");
@@ -1314,7 +1314,7 @@ test("mixed pass: a deferred encrypted target keeps the throttle un-armed so unt
         "deferred target left the throttle un-armed: the second in-window pass recompacts",
       );
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
   } finally {
     await rm(root, { recursive: true, force: true });
@@ -1351,7 +1351,7 @@ test("maintenance drains a pending lifecycle-append spill even when compaction i
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
 
     const ids = (await storage.readAllMemoryLifecycleEvents()).map((e) => e.eventId);
@@ -1433,7 +1433,7 @@ test("maintenance drains a namespace pending spill created after the throttle ar
       );
       await assert.rejects(() => stat(spillPath), /ENOENT/, "namespace spill file removed after drain");
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
   } finally {
     await rm(root, { recursive: true, force: true });
@@ -1487,7 +1487,7 @@ test("auto-compaction bounds per-namespace ledgers, not just the root state path
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
     assert.ok((await stat(nsLedger)).size < beforeSize, "namespace ledger must be compacted");
     const rebuilt = (await readFile(nsLedger, "utf-8")).trim().split("\n").map((l) => JSON.parse(l));
@@ -1529,7 +1529,7 @@ test("catalog-disabled fallback never downgrades an encrypted namespace ledger t
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
     // Skipped, not rewritten: the encrypted ledger must be byte-for-byte intact.
     assert.deepEqual(
@@ -1635,7 +1635,7 @@ test("catalog-disabled fallback compacts an encrypted over-cap namespace ledger
         "encrypted fallback ledger compacts through the keyed store, never deferred forever",
       );
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
 
     // On disk: rewritten, still encrypted at rest (no plaintext downgrade), and
@@ -1755,7 +1755,7 @@ test("catalog-disabled fallback decodes a long tokenized namespace dir so an enc
         "encrypted over-cap ledger for a long namespace compacts through the keyed store, never deferred forever",
       );
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
 
     assert.notDeepEqual(
@@ -1867,7 +1867,7 @@ test("catalog-disabled fallback resolves a LEGACY RAW namespace dir (not a ns- t
         "encrypted over-cap ledger under a legacy raw namespace dir compacts through the keyed store, never deferred forever",
       );
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
 
     assert.notDeepEqual(await readFile(nsLedger), encrypted, "ledger was rewritten (not deferred)");
@@ -1996,7 +1996,7 @@ test("catalog-disabled fallback routes a LEGACY RAW namespace dir through the PR
         "encrypted over-cap ledger under a legacy raw namespace dir compacts through the production-resolved keyed store, never deferred forever",
       );
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
 
     assert.notDeepEqual(await readFile(nsLedger), encrypted, "ledger was rewritten (not deferred)");
@@ -2128,7 +2128,7 @@ test("catalog-disabled fallback refuses a symlinked namespaces scan root (#2033)
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
     assert.equal(
       await readFile(nsLedger, "utf-8"),
@@ -2175,7 +2175,7 @@ test("maintenance request triggers lifecycle compaction even when QMD is unavail
         "lifecycle compaction must be triggered from the maintenance request when QMD is unavailable",
       );
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
@@ -2215,7 +2215,7 @@ test("auto-compaction bounds per-namespace ledgers via filesystem fallback when
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
     assert.ok(
       (await stat(nsLedger)).size < beforeSize,
@@ -2286,7 +2286,7 @@ test("auto-compaction bounds a large append-only history under the read/decrypt
         "throttle armed after an effective bounded compaction: second in-window pass is a no-op",
       );
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
@@ -2328,7 +2328,7 @@ test("filesystem-fallback compaction drains a pending lifecycle append even when
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
 
     const ledger = await readFile(nsLedger, "utf-8");
@@ -2388,7 +2388,7 @@ test("filesystem-fallback compaction recovers a crash-orphaned *.claimed spill w
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
 
     const ledger = await readFile(nsLedger, "utf-8");
@@ -2454,7 +2454,7 @@ test("catalog-disabled fallback drain re-probes encryption UNDER the lock and de
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
 
     // nsA: encrypted spill deferred — byte-for-byte intact, the ledger never got
@@ -2514,7 +2514,7 @@ test("auto-compaction triggers on an encrypted ledger at/above the decrypt cap e
     try {
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
     const afterSize = (await stat(ledgerPath)).size;
     assert.ok(afterSize < beforeSize, "over-cap encrypted ledger must compact despite the larger threshold");
@@ -2572,7 +2572,7 @@ test("auto-compaction bypasses the min-interval throttle for an over-cap encrypt
     try {
       await bypassScheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      bypassScheduler.dispose();
+      await bypassScheduler.dispose();
     }
     const bypassAfter = (await stat(bypassLedger)).size;
     assert.ok(
@@ -2598,7 +2598,7 @@ test("auto-compaction bypasses the min-interval throttle for an over-cap encrypt
     try {
       await throttledScheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      throttledScheduler.dispose();
+      await throttledScheduler.dispose();
     }
     assert.equal(
       (await stat(throttledLedger)).size,
@@ -2684,7 +2684,7 @@ test("auto-compaction reserves the secure-store envelope so an encrypted rewrite
         "throttle armed after an effective encrypted compaction: second in-window pass is a no-op",
       );
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
@@ -2762,7 +2762,7 @@ test("auto-compaction reserves the envelope when a PLAINTEXT ledger will be rewr
         "throttle armed after an effective compaction: second in-window pass is a no-op",
       );
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
@@ -2819,7 +2819,7 @@ test("catalog-disabled fallback pending drain skips unsafe spill entries (symlin
       // (caught by the test timeout) and following the symlink would escape.
       await scheduler.maybeCompactMemoryLifecycleLedger();
     } finally {
-      scheduler.dispose();
+      await scheduler.dispose();
     }
 
     const ledger = await readFile(nsLedger, "utf-8");

package/src/orchestration/maintenance.ts

@@ -57,6 +57,7 @@ import {
   type LifecyclePendingIo,
 } from "../storage/memory-lifecycle-ledger-access.js";
 import { STATE_FILE_MAX_DECRYPT_BYTES } from "../storage/secure-line-reader.js";
+import { ActivitySyncRegistrar } from "../activity/sync-registration.js";
 import { resolveHomeDir } from "../runtime/env.js";
 import { log } from "../logger.js";
 import { isErrnoCode } from "../utils/errno.js";
@@ -133,7 +134,20 @@ export class MaintenanceScheduler {
   // fixture.
   private lifecycleLedgerMaxBytes = STATE_FILE_MAX_DECRYPT_BYTES;
 
-  constructor(private readonly deps: MaintenanceSchedulerDeps) {}
+  // ── Activity (screen-capture) sync scheduler (issue #1900) ──
+  // The full arm/re-arm/teardown lifecycle lives in ActivitySyncRegistrar.
+  private readonly activityRegistrar: ActivitySyncRegistrar;
+
+  constructor(private readonly deps: MaintenanceSchedulerDeps) {
+    this.activityRegistrar = new ActivitySyncRegistrar({
+      config: deps.config.activity,
+      memoryDir: deps.config.memoryDir,
+      qmdCollection: deps.config.qmdCollection,
+      secureStoreEnabled: resolveRecallAuxiliaryCapabilities(deps.config).secureStore,
+      getQmd: () => deps.getQmd(),
+      requestReindexRetry: () => this.requestQmdMaintenanceForTool("activity-reindex-retry"),
+    });
+  }
 
   // ───────────────────────────────────────────────────────────────────────
   // Cron auto-registration
@@ -148,7 +162,7 @@ export class MaintenanceScheduler {
    * Returns when all eligible registrations have completed so callers that
    * `await deferredReady` can rely on jobs.json being current.
    */
-  async autoRegisterCrons(_signal: AbortSignal): Promise<void> {
+  async autoRegisterCrons(signal: AbortSignal): Promise<void> {
     if (resolveRecallAuxiliaryCapabilities(this.deps.config).daySummary) {
       try {
         await this.autoRegisterDaySummaryCron();
@@ -191,6 +205,11 @@ export class MaintenanceScheduler {
         log.debug(`graph edge decay cron auto-register failed (non-fatal): ${err}`);
       }
     }
+
+    // Activity (screen-capture) in-process sync scheduler (issue #1900),
+    // master default-off. The registrar owns the arm/re-arm/teardown contract
+    // (stop-prior, abort/teardown guards, secure-store refusal, retry latch).
+    await this.activityRegistrar.register(signal);
   }
 
   async autoRegisterDaySummaryCron(): Promise<void> {
@@ -1125,10 +1144,23 @@ export class MaintenanceScheduler {
   // ───────────────────────────────────────────────────────────────────────
 
   /**
-   * Clear any pending debounce timer. Called from the orchestrator's
-   * destroy() so a late tick does not fire on a torn-down instance.
+   * Clear any pending debounce timer and drain the activity sync scheduler.
+   * Called from the orchestrator's destroy() so a late tick does not fire on a
+   * torn-down instance and no in-flight activity tick keeps writing after
+   * teardown. Async: awaits the scheduler's abort+drain before resolving.
    */
-  dispose(): void {
+  async dispose(): Promise<void> {
+    // The registrar latches teardown first (so a draining tick's onRun cannot
+    // re-arm QMD maintenance) and aborts+drains the sync. Capture its drain and
+    // await it last so the rest of teardown runs while the aborted tick unwinds.
+    const activityDrain = this.activityRegistrar.dispose();
+    if (this.qmdMaintenanceTimer) {
+      clearTimeout(this.qmdMaintenanceTimer);
+      this.qmdMaintenanceTimer = null;
+    }
+    this.qmdMaintenancePending = false;
+    await activityDrain;
+    // Belt-and-suspenders: clear anything a late tick armed before the latch.
     if (this.qmdMaintenanceTimer) {
       clearTimeout(this.qmdMaintenanceTimer);
       this.qmdMaintenanceTimer = null;

package/src/orchestration/orchestrator-helpers.ts

@@ -601,6 +601,39 @@ export function isArtifactMemoryPath(filePath: string): boolean {
   return /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(filePath);
 }
 
+/** Exactly `activity/<YYYY-MM-DD>.md`, at the top level of a memory root. */
+const ACTIVITY_DIGEST_TOPLEVEL = /^activity[\\/]\d{4}-\d{2}-\d{2}\.md$/i;
+/** The digest FILE shape anywhere in a path (root-unaware best-effort). */
+const ACTIVITY_DIGEST_ANYWHERE = /(?:^|[\\/])activity[\\/]\d{4}-\d{2}-\d{2}\.md$/i;
+
+/**
+ * Activity day-digests live at `<memoryRoot>/activity/<YYYY-MM-DD>.md` — a
+ * dedicated searchable surface (explicit activity search), never generic recall.
+ * Captured screen text must not auto-inject into ordinary prompts (issue #1899).
+ * Keyed on the path (parseFrontmatter drops the digest's `kind` marker).
+ *
+ * Root-aware: when `memoryRoot` is given, the path is resolved relative to it and
+ * must be the TOP-LEVEL `activity/<date>.md`, so an ordinary memory nested under
+ * a category (e.g. `facts/proj/activity/<date>.md`) stays recallable. Without a
+ * root, falls back to the digest file shape anywhere (best-effort).
+ */
+export function isActivityDigestPath(filePath: string, memoryRoot?: string): boolean {
+  if (memoryRoot !== undefined && memoryRoot.length > 0) {
+    const relative = path.relative(memoryRoot, path.resolve(memoryRoot, filePath));
+    return ACTIVITY_DIGEST_TOPLEVEL.test(relative);
+  }
+  return ACTIVITY_DIGEST_ANYWHERE.test(filePath);
+}
+
+/**
+ * Paths that dedicated surfaces own and generic recall must never inject:
+ * artifacts and activity digests. Explicit search paths (memory_search,
+ * activity search) do not apply this filter, so those surfaces still read them.
+ */
+export function isGenericRecallExcludedPath(filePath: string, memoryRoot?: string): boolean {
+  return isArtifactMemoryPath(filePath) || isActivityDigestPath(filePath, memoryRoot);
+}
+
 export function buildCompressionGuidelinesMarkdown(
   events: MemoryActionEvent[],
   generatedAtIso: string = new Date().toISOString(),
@@ -615,6 +648,8 @@ export function filterRecallCandidates(
     recallNamespaces: string[];
     resolveNamespace: (path: string) => string;
     limit: number;
+    /** Memory root for top-level activity-digest detection. */
+    memoryRoot?: string;
   },
 ): QmdSearchResult[] {
   const scopedByNamespace = options.namespacesEnabled
@@ -623,7 +658,7 @@ export function filterRecallCandidates(
       )
     : candidates;
   return scopedByNamespace
-    .filter((r) => !isArtifactMemoryPath(r.path))
+    .filter((r) => !isGenericRecallExcludedPath(r.path, options.memoryRoot))
     .slice(0, Math.max(0, options.limit));
 }
 

package/src/orchestration/recall-internal.ts

@@ -84,7 +84,6 @@ import {
   computeArtifactRecallLimit,
   computeQmdHybridFetchLimit,
   defaultWorkspaceDir,
-  isArtifactMemoryPath,
   raceRecallAbort,
   resolveRecallModeDecision,
   resolveRecallModeDecisionAsync,
@@ -97,6 +96,7 @@ import {
   type QueryAwarePrefilter,
   type RecallInvocationOptions,
 } from "../orchestrator.js";
+import { isGenericRecallExcludedPath } from "./orchestrator-helpers.js";
 
 import type {
   RecallSectionAppendOptions,
@@ -4161,10 +4161,8 @@ export class RecallInternalCoordinator {
         memoryResults = memoryResults.filter((r) =>
           recallNamespaces.includes(r.namespace ?? this.deps.namespaceFromPath(r.path)));
       }
-      // Artifacts are injected through dedicated verbatim recall flow only.
-      memoryResults = memoryResults.filter(
-        (r) => !isArtifactMemoryPath(r.path),
-      );
+      // Artifacts + activity digests are dedicated surfaces, never generic recall.
+      memoryResults = memoryResults.filter((r) => !isGenericRecallExcludedPath(r.path, this.deps.config.memoryDir));
 
       const isFullModeGraphAssist =
         graphCaps.multiGraphMemory &&
@@ -4552,6 +4550,7 @@ export class RecallInternalCoordinator {
                 recallNamespaces,
                 resolveNamespace: (p) => this.deps.namespaceFromPath(p),
                 limit: embeddingFetchLimit,
+                memoryRoot: this.deps.config.memoryDir,
               },
             );
             const boostedScoped = await this.deps.boostSearchResults(
@@ -4749,6 +4748,7 @@ export class RecallInternalCoordinator {
                 recallNamespaces,
                 resolveNamespace: (p) => this.deps.namespaceFromPath(p),
                 limit: embeddingFetchLimit,
+                memoryRoot: this.deps.config.memoryDir,
               },
             );
             const boostedScoped = await this.deps.boostSearchResults(
@@ -4871,7 +4871,7 @@ export class RecallInternalCoordinator {
             typeof asOfMs === "number" && Number.isFinite(asOfMs);
           const activeMemories = memories.filter(
             (m) => {
-              if (isArtifactMemoryPath(m.path)) return false;
+              if (isGenericRecallExcludedPath(m.path, this.deps.config.memoryDir)) return false;
               const status = m.frontmatter.status;
               if (!status || status === "active") return true;
               if (status === "superseded") {

package/src/orchestration/recall-search-pipeline.ts

@@ -54,12 +54,12 @@ import {
   shouldFilterLifecycleRecallCandidate,
   computeQmdHybridFetchLimit,
   filterRecallCandidates,
-  isArtifactMemoryPath,
   throwIfRecallAborted,
   tokenizeRecallQuery,
   type QmdRecallSnapshot,
   type QueryAwarePrefilter,
 } from "../orchestrator.js";
+import { isActivityDigestPath, isGenericRecallExcludedPath } from "./orchestrator-helpers.js";
 
 export interface RecallSearchPipelineDeps {
   applyMemoryWorthRerank(
@@ -466,6 +466,7 @@ export class RecallSearchPipelineCoordinator {
       recallNamespaces: options.recallNamespaces,
       resolveNamespace: options.resolveNamespace,
       limit: qmdFetchLimit,
+      memoryRoot: this.deps.config.memoryDir,
     });
     const emitDebugSnapshot = async (
       results: QmdSearchResult[],
@@ -610,6 +611,7 @@ export class RecallSearchPipelineCoordinator {
         recallNamespaces: options.recallNamespaces,
         resolveNamespace: options.resolveNamespace,
         limit: fetchLimit,
+        memoryRoot: this.deps.config.memoryDir,
       });
 
       if (filteredResults.length >= qmdFetchLimit) {
@@ -693,7 +695,7 @@ export class RecallSearchPipelineCoordinator {
       : [];
     if (scopedSeedResults.length >= cappedLimit) {
       return scopedSeedResults
-        .filter((result) => !isArtifactMemoryPath(result.path))
+        .filter((result) => !isGenericRecallExcludedPath(result.path, this.deps.config.memoryDir))
         .slice(0, cappedLimit);
     }
 
@@ -726,7 +728,7 @@ export class RecallSearchPipelineCoordinator {
       [...scopedSeedResults, ...scored],
       this.deps.namespaceFromPath,
       cappedLimit,
-      { filter: (result) => !isArtifactMemoryPath(result.path) },
+      { filter: (result) => !isGenericRecallExcludedPath(result.path, this.deps.config.memoryDir) },
     );
   }
 
@@ -974,8 +976,9 @@ export class RecallSearchPipelineCoordinator {
       }
       results = scopedResults;
     }
-    // Artifact isolation contract: generic recall paths must exclude artifacts.
-    results = results.filter((r) => !isArtifactMemoryPath(r.path));
+    // Dedicated-surface isolation: generic recall must exclude artifacts and
+    // activity digests (both remain readable via explicit search).
+    results = results.filter((r) => !isGenericRecallExcludedPath(r.path, this.deps.config.memoryDir));
     if (results.length === 0) return [];
 
     const isFullModeGraphAssist =
@@ -1351,10 +1354,15 @@ export class RecallSearchPipelineCoordinator {
           continue;
         }
 
+        // Activity day-digests are a dedicated searchable surface (explicit
+        // activity search), never generic recall — captured screen text must not
+        // auto-inject into ordinary prompts (issue #1899). Keyed on the PATH:
+        // the digest's `kind` frontmatter marker does not survive parseFrontmatter.
         if (
           options?.allowDedicatedSurface !== true &&
           (memory.frontmatter.memoryKind === "dream" ||
-            memory.frontmatter.memoryKind === "procedural")
+            memory.frontmatter.memoryKind === "procedural" ||
+            isActivityDigestPath(memory.path, this.deps.config.memoryDir))
         ) {
           dedicatedSurfaceFilteredCount += 1;
           continue;
@@ -1379,7 +1387,7 @@ export class RecallSearchPipelineCoordinator {
     }
     if (dedicatedSurfaceFilteredCount > 0) {
       log.debug(
-        `dedicated surface filter removed ${dedicatedSurfaceFilteredCount} dream/procedural candidates from generic recall`,
+        `dedicated surface filter removed ${dedicatedSurfaceFilteredCount} dream/procedural/activity-digest candidates from generic recall`,
       );
     }
     if (forgottenFilteredCount > 0) {

package/src/orchestrator-background-writes.test.ts

@@ -21,13 +21,13 @@ test("destroy cancels maintenance and waits for tracked writes before disposing
       compoundingEnabled: false,
     })
   );
-  const maintenanceScheduler = (orchestrator as unknown as { maintenanceScheduler: { dispose(): void } })
+  const maintenanceScheduler = (orchestrator as unknown as { maintenanceScheduler: { dispose(): Promise<void> } })
     .maintenanceScheduler;
   const originalMaintenanceDispose = maintenanceScheduler.dispose.bind(maintenanceScheduler);
   let maintenanceDisposed = false;
   maintenanceScheduler.dispose = () => {
     maintenanceDisposed = true;
-    originalMaintenanceDispose();
+    return originalMaintenanceDispose();
   };
   const writeGate = Promise.withResolvers<void>();
   let destroySettled = false;