From 4ae66fb6f68d07ae89abcb8c058ab0f95f8b1e6a Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 14:39:21 -0800
Subject: [PATCH 1/2] feat(memory): batch learning and surface cited project
 facts

---
 .../components/ProjectKnowledgeEntry.test.tsx | 108 ++++-
 .../src/components/ProjectKnowledgeEntry.tsx  | 159 +++++++-
 .../components/ProjectKnowledgeFactList.tsx   |   4 +-
 .../SettingsServerControlsRouteScreen.tsx     |   2 +-
 .../src/features/threads/ThreadComposer.tsx   |   2 +
 .../src/environment/ServerEnvironment.ts      |   1 +
 .../src/mcp/toolkits/knowledge/tools.ts       |   5 +-
 .../src/orchestration-v2/EffectWorker.test.ts |   6 +-
 .../src/orchestration-v2/EffectWorker.ts      |   2 +-
 .../ProviderTurnStartService.test.ts          |  72 ++++
 .../ProviderTurnStartService.ts               |  83 +++-
 .../server/src/persistence/Migrations.test.ts |  21 +-
 apps/server/src/persistence/Migrations.ts     |   2 +
 .../093_ProjectKnowledgeLearningQueue.ts      |  16 +
 .../knowledge/AssistedLearning.test.ts        | 372 +++++++++++++++++-
 .../src/project/knowledge/AssistedLearning.ts | 361 ++++++++++++++---
 .../knowledge/ProjectKnowledge.test.ts        | 193 ++++++++-
 .../src/project/knowledge/ProjectKnowledge.ts | 164 +++++++-
 .../knowledge/assistedLearningSchedule.ts     |   8 +-
 .../project/knowledge/holographicScoring.ts   |   2 +-
 .../src/project/knowledge/persistence.ts      |   9 +-
 .../src/provider/agentContextBudget.json      |   2 +-
 apps/server/src/server.ts                     |   2 +-
 apps/web/src/components/ChatView.tsx          |   1 +
 .../AssistedLearningSection.tsx               |   4 +-
 .../ProjectMemoryPanel.browser.test.tsx       |  74 +++-
 .../projectKnowledge/ProjectMemoryPanel.tsx   | 100 +++--
 .../ProjectMemorySuggestions.tsx              | 109 +++++
 .../src/components/settings/ZackSettings.tsx  |   4 +-
 docs/user/composer.md                         |  43 +-
 .../src/projectKnowledge/index.test.ts        |  18 +
 .../src/projectKnowledge/index.ts             |  23 ++
 packages/contracts/src/environment.test.ts    |   7 +
 packages/contracts/src/environment.ts         |   1 +
 .../contracts/src/projectKnowledge.test.ts    |  46 +++
 packages/contracts/src/projectKnowledge.ts    |  86 ++++
 .../src/server/textGeneration.ts              |   5 +-
 .../src/server/textGenerationPrompts.test.ts  |  27 ++
 .../src/server/textGenerationPrompts.ts       |  20 +-
 39 files changed, 1978 insertions(+), 186 deletions(-)
 create mode 100644 apps/server/src/persistence/Migrations/093_ProjectKnowledgeLearningQueue.ts
 create mode 100644 apps/web/src/components/projectKnowledge/ProjectMemorySuggestions.tsx

diff --git a/apps/mobile/src/components/ProjectKnowledgeEntry.test.tsx b/apps/mobile/src/components/ProjectKnowledgeEntry.test.tsx
index fea867f7cd530..ff8c1f5d01b4c 100644
--- a/apps/mobile/src/components/ProjectKnowledgeEntry.test.tsx
+++ b/apps/mobile/src/components/ProjectKnowledgeEntry.test.tsx
@@ -26,6 +26,7 @@ const state = vi.hoisted(() => ({
   deliveries: null as unknown,
   readDeliveries: vi.fn(),
   focused: true,
+  previewSupported: true,
   androidSheet: false,
   draft: {} as { text: string; context?: { records: unknown[] } },
   list: null as unknown,
@@ -164,6 +165,7 @@ vi.mock("../state/server", () => ({
       environment: {
         capabilities: {
           projectKnowledge: true,
+          projectKnowledgePreview: state.previewSupported,
           projectKnowledgeHistory: true,
           projectKnowledgeDeliveries: state.deliveryCapabilities[environmentId],
         },
@@ -183,11 +185,11 @@ vi.mock("../state/projectKnowledge", () => ({
     },
     readFact: () => null,
     status: () => null,
-    search: (request: unknown) => {
-      return state.searchRequest(request);
-    },
+    search: Object.assign((request: unknown) => state.searchRequest(request), {
+      permissionAtom: () => true,
+    }),
     readSource: () => state.source,
-    prepareContext: "prepare",
+    prepareContext: { kind: "prepare", permissionAtom: () => true },
     mutate: { permissionAtom: () => true },
   },
 }));
@@ -200,7 +202,8 @@ vi.mock("../state/query", () => ({
   }),
 }));
 vi.mock("../state/use-atom-command", () => ({
-  useAtomCommand: (command: unknown) => (command === "prepare" ? state.prepare : state.mutate),
+  useAtomCommand: (command: unknown) =>
+    (command as { kind?: string }).kind === "prepare" ? state.prepare : state.mutate,
 }));
 vi.mock("../state/use-composer-drafts", () => ({
   useComposerDraft: () => state.draft,
@@ -284,12 +287,16 @@ const deliveryRecord: ProjectKnowledgeDeliveries = {
     },
   ],
 };
-function setup(entries = [scope]) {
+function setup(
+  entries: Array<typeof scope & { suggest?: boolean }> = [scope],
+  previewSupported = true,
+) {
   state.uuidSequence = 0;
   state.deliveryCapabilities = {};
   state.deliveries = null;
   state.readDeliveries.mockReset();
   state.focused = true;
+  state.previewSupported = previewSupported;
   state.androidSheet = false;
   state.draft = { text: "" };
   state.list = { facts: [fact], nextCursor: null };
@@ -949,3 +956,92 @@ it.each(["Hardware Back", "Header Back", "Back", "Cancel"])(
     expect(screen.container.textContent).toContain("Edit");
   },
 );
+
+it("recalls a completed first draft once and dismisses a suggestion without attaching it", async () => {
+  using screen = setup([{ ...scope, suggest: true }]);
+  vi.useFakeTimers();
+  try {
+    expect(state.searchRequest).not.toHaveBeenCalled();
+    state.draft = { text: "Change the cache keys" };
+    screen.rerender();
+    await act(async () => vi.advanceTimersByTimeAsync(500));
+    expect(state.searchRequest).not.toHaveBeenCalled();
+    state.draft = { text: "Change the cache keys to include tenant IDs." };
+    state.search = {
+      messages: { matches: [], nextCursor: null },
+      facts: {
+        state: "available",
+        coverage: "complete",
+        nextCursor: null,
+        matches: [
+          {
+            fact: {
+              ...fact,
+              trust: 0.9,
+              sources: [
+                {
+                  kind: "message",
+                  threadId: ThreadId.make("source"),
+                  messageId: MessageId.make("source-message"),
+                  digest: "a".repeat(64),
+                },
+              ],
+            },
+            score: {
+              holographic: 0.9,
+              lexical: 0.9,
+              tokenOverlap: 0.9,
+              temporalDecay: 1,
+              reinforcement: 1,
+              trust: 0.9,
+              combined: 0.9,
+            },
+          },
+        ],
+      },
+    };
+    screen.rerender();
+    await act(async () => vi.advanceTimersByTimeAsync(1000));
+    expect(screen.container.textContent).toContain("Project memory:");
+    expect(state.searchRequest.mock.calls[0]?.[0].input).toMatchObject({
+      query: state.draft.text,
+      recordRetrieval: false,
+      projectId: scope.projectId,
+    });
+    const recalledDraft = state.draft.text;
+    state.draft = { text: `${recalledDraft} Keep the existing conventions.` };
+    screen.rerender();
+    expect(screen.container.textContent).toContain("Project memory:");
+    state.draft = { text: "Replace the sign in page with a new layout." };
+    screen.rerender();
+    expect(screen.container.textContent).not.toContain("Project memory:");
+    state.draft = { text: recalledDraft };
+    screen.rerender();
+    expect(screen.container.textContent).toContain("Project memory:");
+    await screen.click("Dismiss");
+    expect(screen.container.textContent).not.toContain("Project memory:");
+    expect(state.prepare).not.toHaveBeenCalled();
+    expect(state.insert).not.toHaveBeenCalled();
+    state.draft = { text: "Another request about tenant cache keys." };
+    screen.rerender();
+    await act(async () => vi.advanceTimersByTimeAsync(2000));
+    expect(
+      new Set(state.searchRequest.mock.calls.map(([request]) => request.input.requestId)).size,
+    ).toBe(1);
+  } finally {
+    vi.useRealTimers();
+  }
+});
+
+it("keeps passive draft recall off for servers without preview support", async () => {
+  using screen = setup([{ ...scope, suggest: true }], false);
+  vi.useFakeTimers();
+  try {
+    state.draft = { text: "Change cache keys to include tenant IDs." };
+    screen.rerender();
+    await act(async () => vi.advanceTimersByTimeAsync(2000));
+    expect(state.searchRequest).not.toHaveBeenCalled();
+  } finally {
+    vi.useRealTimers();
+  }
+});
diff --git a/apps/mobile/src/components/ProjectKnowledgeEntry.tsx b/apps/mobile/src/components/ProjectKnowledgeEntry.tsx
index 4a0142b201da6..7535fbfda5f77 100644
--- a/apps/mobile/src/components/ProjectKnowledgeEntry.tsx
+++ b/apps/mobile/src/components/ProjectKnowledgeEntry.tsx
@@ -18,6 +18,12 @@ import {
   type ProjectKnowledgeSource,
   type ThreadId,
 } from "@t3tools/contracts";
+import {
+  addProjectMemorySuggestion,
+  boundProjectMemorySuggestionQuery,
+  isSubstantiveProjectMemoryQuery,
+  selectProjectMemorySuggestions,
+} from "@t3tools/client-runtime/projectKnowledge";
 import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
 
 import {
@@ -64,6 +70,7 @@ type Scope = {
   readonly projectId: ProjectId;
   readonly draftKey: string;
   readonly disabled: boolean;
+  readonly suggest?: boolean;
 };
 type MessageCitation = { readonly threadId: ThreadId; readonly messageId: MessageId };
 // The digest is optional so a feed message can be cited before the server has
@@ -108,7 +115,11 @@ export function useOpenProjectMemory(
 export function ProjectKnowledgeEntry(props: Scope) {
   const isFocused = useIsFocused();
   const config = useAtomValue(serverEnvironment.configValueAtom(props.environmentId));
-  const [open, setOpen] = useState<{ readonly seed: MessageCitation | null } | null>(null);
+  const [open, setOpen] = useState<{
+    readonly seed: MessageCitation | null;
+    readonly fact?: ProjectFact;
+    readonly source?: KnowledgeMessageRef;
+  } | null>(null);
   const { environmentId, projectId, draftKey } = props;
   // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- registers this entry with the header and feed open requests while mounted
   useEffect(() => {
@@ -126,18 +137,31 @@ export function ProjectKnowledgeEntry(props: Scope) {
       openListeners.delete(listener);
     };
   }, [environmentId, projectId, draftKey, isFocused]);
-  if (config?.environment.capabilities.projectKnowledge !== true || !open || !isFocused)
-    return null;
+  if (config?.environment.capabilities.projectKnowledge !== true || !isFocused) return null;
   return (
-    <ProjectKnowledgeSheet
-      key={`${props.environmentId}:${props.projectId}:${props.draftKey}:${open.seed?.messageId ?? ""}`}
-      {...props}
-      // Older servers lack readFact, status and supersede.
-      history={config.environment.capabilities.projectKnowledgeHistory === true}
-      assisted={config.environment.capabilities.projectKnowledgeAssistedLearning === true}
-      seedMessage={open.seed}
-      onClose={() => setOpen(null)}
-    />
+    <>
+      {props.suggest && config.environment.capabilities.projectKnowledgePreview === true ? (
+        <ProjectMemorySuggestions
+          key={`${props.environmentId}:${props.projectId}:${props.draftKey}`}
+          {...props}
+          onUse={(fact) => setOpen({ seed: null, fact })}
+          onSource={(source) => setOpen({ seed: null, source })}
+        />
+      ) : null}
+      {open ? (
+        <ProjectKnowledgeSheet
+          key={`${props.environmentId}:${props.projectId}:${props.draftKey}:${open.seed?.messageId ?? open.source?.messageId ?? open.fact?.id ?? ""}`}
+          {...props}
+          // Older servers lack readFact, status and supersede.
+          history={config.environment.capabilities.projectKnowledgeHistory === true}
+          assisted={config.environment.capabilities.projectKnowledgeAssistedLearning === true}
+          seedMessage={open.seed}
+          suggestedFact={open.fact}
+          suggestedSource={open.source}
+          onClose={() => setOpen(null)}
+        />
+      ) : null}
+    </>
   );
 }
 
@@ -146,6 +170,8 @@ function ProjectKnowledgeSheet(
     readonly history: boolean;
     readonly assisted: boolean;
     readonly seedMessage: MessageCitation | null;
+    readonly suggestedFact?: ProjectFact;
+    readonly suggestedSource?: KnowledgeMessageRef;
     readonly onClose: () => void;
   },
 ) {
@@ -158,14 +184,23 @@ function ProjectKnowledgeSheet(
   const attachedInScope =
     attached && projectKnowledgeRecordInScope(attached, scope) ? attached : undefined;
   const [selections, setSelections] = useState<ReadonlyArray<KnowledgeSelection>>(
-    attachedInScope?.knowledge.selections ?? [],
+    props.suggestedFact
+      ? addProjectMemorySuggestion(attachedInScope?.knowledge.selections ?? [], props.suggestedFact)
+      : (attachedInScope?.knowledge.selections ?? []),
   );
   // Set when a selection change removed the reference this sheet opened with.
   const [detached, setDetached] = useState(false);
   const [stack, setStack] = useState<ReadonlyArray<Page>>(
-    props.seedMessage
-      ? [{ kind: "list" }, { kind: "remember", ref: props.seedMessage }]
-      : [{ kind: "list" }],
+    props.suggestedFact
+      ? [
+          { kind: "list" },
+          { kind: "fact", factId: props.suggestedFact.id, snapshot: props.suggestedFact },
+        ]
+      : props.suggestedSource
+        ? [{ kind: "list" }, { kind: "source", ref: props.suggestedSource }]
+        : props.seedMessage
+          ? [{ kind: "list" }, { kind: "remember", ref: props.seedMessage }]
+          : [{ kind: "list" }],
   );
   const page = stack.at(-1)!;
   const [hints, setHints] = useState<{
@@ -634,3 +669,95 @@ function RememberEditor(props: {
     />
   );
 }
+
+function ProjectMemorySuggestions(
+  props: Scope & {
+    readonly onUse: (fact: ProjectFact) => void;
+    readonly onSource: (source: KnowledgeMessageRef) => void;
+  },
+) {
+  const canUse = useAtomValue(projectKnowledge.prepareContext.permissionAtom(props.environmentId));
+  const draft = useComposerDraft(props.draftKey);
+  const [request, setRequest] = useState<{ query: string; requestId: CommandId } | null>(null);
+  const [dismissed, setDismissed] = useState<ReadonlyArray<string>>([]);
+  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- issues one recall request after the user pauses composing a substantive draft
+  useEffect(() => {
+    if (request || !isSubstantiveProjectMemoryQuery(draft.text)) return;
+    const timer = setTimeout(
+      () =>
+        setRequest({
+          query: boundProjectMemorySuggestionQuery(draft.text),
+          requestId: CommandId.make(uuidv4()),
+        }),
+      1000,
+    );
+    return () => clearTimeout(timer);
+  }, [draft.text, request]);
+  const result = useEnvironmentQuery(
+    request
+      ? projectKnowledge.search({
+          environmentId: props.environmentId,
+          input: {
+            ...request,
+            projectId: props.projectId,
+            recordRetrieval: false,
+            preview: true,
+            minTrust: 0.5,
+            limit: 8,
+            messageLimit: 1,
+          },
+        })
+      : null,
+  );
+  const suggestions = result.data
+    ? selectProjectMemorySuggestions(result.data, request?.query).filter(
+        ({ fact }) => !dismissed.includes(fact.id),
+      )
+    : [];
+  if (!request || !draft.text.trimStart().startsWith(request.query) || !suggestions.length)
+    return null;
+  return (
+    <View accessibilityLabel="Related project memory" className="gap-1">
+      {suggestions.map(({ fact, reason }) => (
+        <View key={fact.id} className="gap-1">
+          <AppText numberOfLines={2}>Project memory: {fact.content}</AppText>
+          <AppText>{reason}</AppText>
+          <View className="flex-row gap-1">
+            {fact.sources.some((source) => source.kind === "user") ? (
+              <AppText>Saved by you</AppText>
+            ) : null}
+            {fact.sources
+              .filter((source) => source.kind === "message")
+              .slice(0, 1)
+              .flatMap((source) =>
+                source.kind === "message"
+                  ? [
+                      <Button
+                        key={source.messageId}
+                        label="Source"
+                        size="compact"
+                        tone="text"
+                        onPress={() => props.onSource(source)}
+                      />,
+                    ]
+                  : [],
+              )}
+            <Button
+              label="Use"
+              size="compact"
+              tone="text"
+              disabled={props.disabled || !canUse}
+              onPress={() => props.onUse(fact)}
+            />
+            <Button
+              label="Dismiss"
+              size="compact"
+              tone="text"
+              onPress={() => setDismissed([...dismissed, fact.id])}
+            />
+          </View>
+        </View>
+      ))}
+    </View>
+  );
+}
diff --git a/apps/mobile/src/components/ProjectKnowledgeFactList.tsx b/apps/mobile/src/components/ProjectKnowledgeFactList.tsx
index 1f7c4732ef5e1..dd4594a384962 100644
--- a/apps/mobile/src/components/ProjectKnowledgeFactList.tsx
+++ b/apps/mobile/src/components/ProjectKnowledgeFactList.tsx
@@ -469,8 +469,8 @@ function AssistedLearningRow(props: {
         />
       </View>
       <AppText className="text-xs text-foreground-muted">
-        After each run in this project, your text generation model saves up to three cited facts.
-        Each run costs one model call.
+        Completed runs are grouped into background learning batches. Your text generation model
+        saves up to three cited facts per batch; eligible batches use at most one model call.
       </AppText>
       {props.lastRun ? (
         <AppText className="text-xs">{assistedLearningRunLabel(props.lastRun)}</AppText>
diff --git a/apps/mobile/src/features/settings/SettingsServerControlsRouteScreen.tsx b/apps/mobile/src/features/settings/SettingsServerControlsRouteScreen.tsx
index ddedee9d5154b..201d7c42663af 100644
--- a/apps/mobile/src/features/settings/SettingsServerControlsRouteScreen.tsx
+++ b/apps/mobile/src/features/settings/SettingsServerControlsRouteScreen.tsx
@@ -444,7 +444,7 @@ function ServerSettingsDetail(props: { readonly page: SettingsPage }) {
                     label="Save facts from finished runs"
                     subtitle={
                       assistedLearningUnavailableReason ??
-                      "After each run, your text generation model saves up to three cited facts. Each run costs one model call."
+                      "Completed runs are grouped into background learning batches. Your text generation model saves up to three cited facts per batch; eligible batches use at most one model call."
                     }
                     value={uniform("enableAssistedLearning")}
                     disabled={
diff --git a/apps/mobile/src/features/threads/ThreadComposer.tsx b/apps/mobile/src/features/threads/ThreadComposer.tsx
index 134efebc209b7..a9e3e55fd8f40 100644
--- a/apps/mobile/src/features/threads/ThreadComposer.tsx
+++ b/apps/mobile/src/features/threads/ThreadComposer.tsx
@@ -910,6 +910,8 @@ export const ThreadComposer = function ThreadComposer(props: ThreadComposerProps
 
         {!props.hidden && composerDraftKey ? (
           <ProjectKnowledgeEntry
+            key={`${props.environmentId}:${props.selectedThread.projectId}:${composerDraftKey}`}
+            suggest={props.selectedThread.latestUserMessageAt === null}
             environmentId={props.environmentId}
             projectId={props.selectedThread.projectId}
             draftKey={composerDraftKey}
diff --git a/apps/server/src/environment/ServerEnvironment.ts b/apps/server/src/environment/ServerEnvironment.ts
index c17483820e3c2..e6f1018feef98 100644
--- a/apps/server/src/environment/ServerEnvironment.ts
+++ b/apps/server/src/environment/ServerEnvironment.ts
@@ -229,6 +229,7 @@ export const make = Effect.gen(function* () {
       sideChats: true,
       inlineMessageContext: true,
       projectKnowledge: true,
+      projectKnowledgePreview: true,
       projectKnowledgeHistory: true,
       projectKnowledgeDeliveries: true,
       projectKnowledgeAssistedLearning: true,
diff --git a/apps/server/src/mcp/toolkits/knowledge/tools.ts b/apps/server/src/mcp/toolkits/knowledge/tools.ts
index 3ac8b512616cd..71622a1292df8 100644
--- a/apps/server/src/mcp/toolkits/knowledge/tools.ts
+++ b/apps/server/src/mcp/toolkits/knowledge/tools.ts
@@ -18,6 +18,7 @@ import {
 } from "@t3tools/contracts";
 import { Tool, Toolkit } from "effect/ai";
 import * as Schema from "effect/Schema";
+import * as Struct from "effect/Struct";
 import * as ProjectKnowledge from "../../../project/knowledge/ProjectKnowledge.ts";
 import * as ThreadManagement from "../../../orchestration-v2/ThreadManagementService.ts";
 import * as McpInvocationContext from "../../McpInvocationContext.ts";
@@ -35,9 +36,9 @@ export const KnowledgeToolkit = Toolkit.make(
   Tool.make("t3_knowledge_search", {
     ...shared,
     description:
-      "Use when a task depends on prior project decisions, conventions, constraints, or agent observations. Resolve projectId from the selected environment's registered projects with t3_project_list and t3_project_read using the same environmentId. Recall is on demand; facts are not automatically added to the prompt. Read returned message citations with t3_knowledge_read_source in that same environment before relying on them. Facts use holographic and lexical ranking. Unavailable ranking is explicit. Superseded facts are excluded unless includeSuperseded is set. Reuse requestId for retries so retrieval is counted once.",
+      "Use when a task depends on prior project decisions, conventions, constraints, or agent observations. Resolve projectId from the selected environment's registered projects with t3_project_list and t3_project_read using the same environmentId. Read returned message citations with t3_knowledge_read_source in that same environment before relying on them. Facts use holographic and lexical ranking. Unavailable ranking is explicit. Superseded facts are excluded unless includeSuperseded is set. Reuse requestId for retries so retrieval is counted once.",
     parameters: Schema.Struct({
-      ...ProjectKnowledgeSearchInput.fields,
+      ...Struct.omit(ProjectKnowledgeSearchInput.fields, ["preview"]),
       environmentId: OrchestratorMcpEnvironmentTarget,
     }),
     success: ProjectKnowledgeSearchResult,
diff --git a/apps/server/src/orchestration-v2/EffectWorker.test.ts b/apps/server/src/orchestration-v2/EffectWorker.test.ts
index 35e4e5a50b7bb..7a679e79940f5 100644
--- a/apps/server/src/orchestration-v2/EffectWorker.test.ts
+++ b/apps/server/src/orchestration-v2/EffectWorker.test.ts
@@ -379,7 +379,11 @@ it.effect.each(["project-knowledge.extract", "conversation-summary.generate"] as
         Effect.andThen(Deferred.await(release)),
       );
       const runners = Layer.merge(
-        Layer.succeed(AssistedLearningRunner, { extractRun: () => hold }),
+        Layer.succeed(AssistedLearningRunner, {
+          extractRun: () => hold,
+          enqueueRun: () => hold,
+          drainDue: Effect.void,
+        }),
         Layer.succeed(ConversationSummaryRuntime, {
           summarizeThread: () => hold.pipe(Effect.as({ hasMore: false })),
           forHandoff: () => Effect.succeed([]),
diff --git a/apps/server/src/orchestration-v2/EffectWorker.ts b/apps/server/src/orchestration-v2/EffectWorker.ts
index c3de68625a478..7c244c1f951ed 100644
--- a/apps/server/src/orchestration-v2/EffectWorker.ts
+++ b/apps/server/src/orchestration-v2/EffectWorker.ts
@@ -604,7 +604,7 @@ export const layerExecutor: Layer.Layer<
             );
           case "project-knowledge.extract":
             return assistedLearning
-              .extractRun({
+              .enqueueRun({
                 threadId: effect.threadId,
                 runId: effect.request.runId,
                 runOutcome: effect.request.runOutcome,
diff --git a/apps/server/src/orchestration-v2/ProviderTurnStartService.test.ts b/apps/server/src/orchestration-v2/ProviderTurnStartService.test.ts
index 5dd8cb00ba360..b2a6250a8d53d 100644
--- a/apps/server/src/orchestration-v2/ProviderTurnStartService.test.ts
+++ b/apps/server/src/orchestration-v2/ProviderTurnStartService.test.ts
@@ -292,6 +292,7 @@ function makeLocalCommandHarness(input: {
   readonly initialDeliveries?: ReadonlyArray<ProjectKnowledgeDelivery>;
   readonly recoveryNativeId?: string;
   readonly modelContextWindow?: number;
+  readonly suggestKnowledge?: ProjectKnowledge.ProjectKnowledge["Service"]["suggest"];
   readonly resolveKnowledge?: ProjectKnowledge.ProjectKnowledge["Service"]["resolveForTurn"];
   readonly readSentDeliveries?: ProjectKnowledge.ProjectKnowledge["Service"]["readSentDeliveries"];
   readonly worktreePath?: string;
@@ -985,6 +986,7 @@ function makeLocalCommandHarness(input: {
     Layer.provide(
       Layer.mergeAll(
         Layer.mock(ProjectKnowledge.ProjectKnowledge)({
+          ...(input.suggestKnowledge ? { suggest: input.suggestKnowledge } : {}),
           ...(input.resolveKnowledge ? { resolveForTurn: input.resolveKnowledge } : {}),
           ...(input.readSentDeliveries ? { readSentDeliveries: input.readSentDeliveries } : {}),
           nativeDeliveryEstimate: (target) =>
@@ -1449,6 +1451,76 @@ effectIt.effect("recovers an abandoned failed turn before continuing its native
   }),
 );
 
+effectIt.effect("offers bounded fact references to unattended first turns only", () =>
+  Effect.gen(function* () {
+    const text = "Review SQLite migrations for project memory";
+    const projectId = ProjectId.make("project-native-account-command");
+    const suggest = vi.fn<ProjectKnowledge.ProjectKnowledge["Service"]["suggest"]>(() =>
+      Effect.succeed([
+        {
+          fact: {
+            id: ProjectFactId.make("fact-migrations"),
+            projectId,
+            status: "saved",
+            kind: "decision",
+            origin: { kind: "user" },
+            content: "Private assertion body",
+            entities: [],
+            tags: [],
+            sources: [{ kind: "user" }],
+            revision: 1,
+            trust: 0.8,
+            retrievalCount: 0,
+            createdAt: "2026-09-04T12:00:00.000Z",
+            updatedAt: "2026-09-04T12:00:00.000Z",
+            forgottenAt: null,
+          },
+          score: {
+            holographic: 1,
+            lexical: 1,
+            tokenOverlap: 1,
+            temporalDecay: 1,
+            reinforcement: 0,
+            trust: 0.8,
+            combined: 1,
+          },
+          reason: "Private match explanation",
+        },
+      ]),
+    );
+    for (const [source, ordinal] of [
+      ["web", 1],
+      ["mobile", 1],
+      ["mcp", 2],
+      ["mcp", 1],
+    ] as const) {
+      const harness = makeLocalCommandHarness({
+        text,
+        previousTurn: { runStatus: "completed", turnStatus: "completed" },
+        suggestKnowledge: suggest,
+      });
+      const projection = harness.projection();
+      harness.setProjection({
+        ...projection,
+        runs: projection.runs.map((run) => (run.status === "starting" ? { ...run, ordinal } : run)),
+        messages: projection.messages.map((message) => ({ ...message, creationSource: source })),
+      });
+      yield* harness.start;
+      const prompt = harness.startRootRun.mock.calls[0]?.[0].message.text;
+      if (source === "mcp" && ordinal === 1) {
+        expect(suggest).toHaveBeenCalledOnce();
+        expect(suggest.mock.calls[0]?.[0]).toMatchObject({ projectId, query: text });
+        expect(prompt).toContain("fact-migrations");
+        expect(prompt).toContain(text);
+        expect(prompt).not.toContain("Private");
+      } else {
+        expect(suggest).not.toHaveBeenCalled();
+        expect(prompt).toBe(text);
+      }
+    }
+  }),
+);
+
 effectIt.effect.each([
   { contextRun: "current", runtimeMode: "full-access", context: "SIDE_CHAT_CONTEXT" },
   { contextRun: "failed", runtimeMode: "full-access", context: "SIDE_CHAT_CONTEXT" },
diff --git a/apps/server/src/orchestration-v2/ProviderTurnStartService.ts b/apps/server/src/orchestration-v2/ProviderTurnStartService.ts
index 73029a242d6df..4b04274c34299 100644
--- a/apps/server/src/orchestration-v2/ProviderTurnStartService.ts
+++ b/apps/server/src/orchestration-v2/ProviderTurnStartService.ts
@@ -13,10 +13,12 @@ import {
   type OrchestrationV2ExecutionNode,
   type OrchestrationV2ProviderThread,
   type OrchestrationV2Run,
+  type ProjectId,
   type OrchestrationV2RunAttempt,
   type OrchestrationV2TurnItem,
   type RunAttemptId,
   isCompactionCommandMessage,
+  isSubstantiveProjectMemoryQuery,
   parseGoalCommand,
   RunId,
   ThreadId,
@@ -123,6 +125,34 @@ const refusedBeforePrompt = (error: unknown): boolean =>
   PROMPT_REFUSAL_TAGS.some((tag) => Predicate.isTagged(error, tag)) ||
   (Predicate.hasProperty(error, "cause") && refusedBeforePrompt(error.cause));
 
+const unattendedMemoryHint = Effect.fn("ProviderTurnStartService.unattendedMemoryHint")(function* (
+  knowledge: ProjectKnowledge.ProjectKnowledge["Service"],
+  projectId: ProjectId,
+  runId: RunId,
+  query: string,
+) {
+  const matches = yield* knowledge
+    .suggest({
+      projectId,
+      requestId: CommandId.make(`memory-preview:${runId}`),
+      query,
+    })
+    .pipe(
+      Effect.timeoutOption("150 millis"),
+      Effect.orElseSucceed(() => Option.none()),
+    );
+  // IDs can also be supplied by clients. Only opaque identifiers belong in a provider hint.
+  const opaqueId = /^[a-zA-Z0-9_:.-]{1,128}$/;
+  if (Option.isNone(matches) || !opaqueId.test(projectId)) return "";
+  const ids = matches.value
+    .map(({ fact }) => fact.id)
+    .filter((id) => opaqueId.test(id))
+    .slice(0, 2);
+  return ids.length === 0
+    ? ""
+    : `Related project memory in ${projectId}. Read by fact ID with t3_knowledge_read_fact: ${ids.join(", ")}.`;
+});
+
 export interface ProviderTurnStartServiceV2Shape {
   readonly start: (input: {
     readonly threadId: ThreadId;
@@ -1581,21 +1611,44 @@ export const layer: Layer.Layer<
       const initialDeliveryState = yield* knowledgeDelivery.readState;
       userText = initialDeliveryState.sent ? composer.baseText : composer.text;
       {
-        yield* knowledgeDelivery.checkBudget(
-          handoffBudgetAssumptions({
-            tokenCap,
-            modelContextWindow,
-            userText:
-              restartNote === "" ? composer.baseText : `${restartNote}\n\n${composer.baseText}`,
-            attachments: message.attachments,
-            providerThread: budgetProviderThread,
-            nativeContextEstimate:
-              budgetProviderThread.contextUsage?.usedTokens === undefined
-                ? yield* nativeContextEstimate
-                : 0,
-          }),
-          initialDeliveryState.sent,
-        );
+        const budget = handoffBudgetAssumptions({
+          tokenCap,
+          modelContextWindow,
+          userText:
+            restartNote === "" ? composer.baseText : `${restartNote}\n\n${composer.baseText}`,
+          attachments: message.attachments,
+          providerThread: budgetProviderThread,
+          nativeContextEstimate:
+            budgetProviderThread.contextUsage?.usedTokens === undefined
+              ? yield* nativeContextEstimate
+              : 0,
+        });
+        yield* knowledgeDelivery.checkBudget(budget, initialDeliveryState.sent);
+        // People choose suggestions in the composer. Unattended starts can discover the same facts by ID.
+        if (
+          (message.creationSource === "mcp" || message.creationSource === "server") &&
+          run.ordinal === 1 &&
+          attempt.attemptOrdinal === 1 &&
+          (session.supportsT3Tools ??
+            session.providerSession.capabilities.tools.supportsMcpTools) &&
+          !noteContinuation &&
+          restartNote === "" &&
+          effectiveHandoffs.length === 0 &&
+          retryHandoff.length === 0 &&
+          sideChatHandoff === undefined &&
+          (message.context?.records.length ?? 0) === 0 &&
+          !message.text.trimStart().startsWith("/") &&
+          budget.knowledgeAllowance >= 512 &&
+          isSubstantiveProjectMemoryQuery(message.text)
+        ) {
+          const hint = yield* unattendedMemoryHint(
+            knowledge,
+            projection.thread.projectId,
+            run.id,
+            message.text,
+          );
+          userText = withInlineContext(hint, userText);
+        }
         if (!(yield* isCurrentAttemptInStatus("running"))) return;
       }
       const persistHandoff = Effect.fn("ProviderTurnStartService.persist")(function* (
diff --git a/apps/server/src/persistence/Migrations.test.ts b/apps/server/src/persistence/Migrations.test.ts
index 9787393005f67..d1179ef664ca7 100644
--- a/apps/server/src/persistence/Migrations.test.ts
+++ b/apps/server/src/persistence/Migrations.test.ts
@@ -26,6 +26,7 @@ const delegatedRecoveryMigration = [89, "DelegatedRecoveryIndexes"] as const;
 const scheduledTaskThreadModeMigration = [90, "ScheduledTaskThreadMode"] as const;
 const dropProjectLoomIndexesMigration = [91, "DropProjectLoomIndexes"] as const;
 const savedLifecycleMigration = [92, "ProjectKnowledgeSavedLifecycle"] as const;
+const learningQueueMigration = [93, "ProjectKnowledgeLearningQueue"] as const;
 
 it.effect("upgrades attempt receipts atomically and preserves distinct steering messages", () =>
   Effect.gen(function* () {
@@ -53,6 +54,7 @@ it.effect("upgrades attempt receipts atomically and preserves distinct steering
       scheduledTaskThreadModeMigration,
       dropProjectLoomIndexesMigration,
       savedLifecycleMigration,
+      learningQueueMigration,
     ]);
     assert.deepStrictEqual(yield* sql`SELECT * FROM project_knowledge_deliveries`, before);
     yield* sql`INSERT INTO project_knowledge_deliveries (
@@ -195,7 +197,10 @@ it.effect("rebuilds knowledge facts as saved or forgotten, atomically and in pla
     yield* sql`DROP VIEW project_knowledge_facts_saved`;
     assert.deepStrictEqual(yield* schema, schemaBefore);
 
-    assert.deepStrictEqual(yield* runMigrations(), [savedLifecycleMigration]);
+    assert.deepStrictEqual(yield* runMigrations(), [
+      savedLifecycleMigration,
+      learningQueueMigration,
+    ]);
 
     const cleared = new Set([
       "edited-pending",
@@ -286,6 +291,8 @@ it.effect("rebuilds knowledge facts as saved or forgotten, atomically and in pla
     const savedCommands = yield* commands;
     const savedRuns = yield* sql`SELECT * FROM project_knowledge_assisted_runs`;
     const savedSchema = yield* schema;
+    yield* sql`DROP TABLE project_knowledge_learning_queue`;
+    yield* sql`DELETE FROM effect_sql_migrations WHERE migration_id = 93`;
     yield* ProjectLoomTimeIndexes;
     yield* ProjectLoomBoundedReads;
     yield* previewLoomIndexes;
@@ -325,7 +332,10 @@ it.effect("rebuilds knowledge facts as saved or forgotten, atomically and in pla
     assert.deepStrictEqual(yield* schema, rollbackSchema);
     yield* sql`DROP TRIGGER reject_saved_preview_receipt`;
 
-    assert.deepStrictEqual(yield* runMigrations(), [dropProjectLoomIndexesMigration]);
+    assert.deepStrictEqual(yield* runMigrations(), [
+      dropProjectLoomIndexesMigration,
+      learningQueueMigration,
+    ]);
     assert.deepStrictEqual(yield* facts, savedFacts);
     assert.deepStrictEqual(yield* history, savedHistory);
     assert.deepStrictEqual(yield* commands, savedCommands);
@@ -676,6 +686,7 @@ describe("runMigrations", () => {
             scheduledTaskThreadModeMigration,
             dropProjectLoomIndexesMigration,
             savedLifecycleMigration,
+            learningQueueMigration,
           ],
         );
         yield* assertConsolidatedSchema;
@@ -719,6 +730,7 @@ describe("runMigrations", () => {
           scheduledTaskThreadModeMigration,
           dropProjectLoomIndexesMigration,
           savedLifecycleMigration,
+          learningQueueMigration,
         ],
       );
       assert.deepStrictEqual(yield* runMigrations(), [
@@ -735,6 +747,7 @@ describe("runMigrations", () => {
         scheduledTaskThreadModeMigration,
         dropProjectLoomIndexesMigration,
         savedLifecycleMigration,
+        learningQueueMigration,
       ]);
       yield* assertConsolidatedSchema;
       assert.deepStrictEqual(
@@ -773,6 +786,7 @@ describe("runMigrations", () => {
           scheduledTaskThreadModeMigration,
           dropProjectLoomIndexesMigration,
           savedLifecycleMigration,
+          learningQueueMigration,
         ]);
 
         yield* assertConsolidatedSchema;
@@ -881,6 +895,7 @@ describe("runMigrations", () => {
         scheduledTaskThreadModeMigration,
         dropProjectLoomIndexesMigration,
         savedLifecycleMigration,
+        learningQueueMigration,
       ]);
       yield* assertConsolidatedSchema;
       assert.deepStrictEqual(yield* sql`SELECT secret_name, fenced FROM peer_environment_links`, [
@@ -938,6 +953,7 @@ describe("runMigrations", () => {
           scheduledTaskThreadModeMigration,
           dropProjectLoomIndexesMigration,
           savedLifecycleMigration,
+          learningQueueMigration,
         ]);
         assert.deepStrictEqual(yield* history, migrationManifest);
         assert.deepStrictEqual(
@@ -1000,6 +1016,7 @@ describe("runMigrations", () => {
           scheduledTaskThreadModeMigration,
           dropProjectLoomIndexesMigration,
           savedLifecycleMigration,
+          learningQueueMigration,
         ]);
         assert.deepStrictEqual(yield* history, migrationManifest);
         assert.deepStrictEqual(yield* sql`SELECT * FROM cross_environment_launches`, routes);
diff --git a/apps/server/src/persistence/Migrations.ts b/apps/server/src/persistence/Migrations.ts
index ba40649f0145c..8c742eb664061 100644
--- a/apps/server/src/persistence/Migrations.ts
+++ b/apps/server/src/persistence/Migrations.ts
@@ -97,6 +97,7 @@ import Migration0088 from "./Migrations/088_ModelEvaluations.ts";
 import Migration0089 from "./Migrations/089_DelegatedRecoveryIndexes.ts";
 import Migration0090 from "./Migrations/090_ScheduledTaskThreadMode.ts";
 import Migration0091 from "./Migrations/091_DropProjectLoomIndexes.ts";
+import Migration0093 from "./Migrations/093_ProjectKnowledgeLearningQueue.ts";
 import Migration0092 from "./Migrations/092_ProjectKnowledgeSavedLifecycle.ts";
 
 const migrationEntries = [
@@ -193,6 +194,7 @@ const migrationEntries = [
   [90, "ScheduledTaskThreadMode", Migration0090],
   [91, "DropProjectLoomIndexes", Migration0091],
   [92, "ProjectKnowledgeSavedLifecycle", Migration0092],
+  [93, "ProjectKnowledgeLearningQueue", Migration0093],
 ] as const;
 
 export const migrationManifest = migrationEntries.map(([id, name]) => [id, name] as const);
diff --git a/apps/server/src/persistence/Migrations/093_ProjectKnowledgeLearningQueue.ts b/apps/server/src/persistence/Migrations/093_ProjectKnowledgeLearningQueue.ts
new file mode 100644
index 0000000000000..498391e09ff9e
--- /dev/null
+++ b/apps/server/src/persistence/Migrations/093_ProjectKnowledgeLearningQueue.ts
@@ -0,0 +1,16 @@
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/sql/SqlClient";
+
+export default Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  yield* sql`CREATE TABLE project_knowledge_learning_queue (
+    run_id TEXT PRIMARY KEY NOT NULL,
+    project_id TEXT NOT NULL,
+    root_thread_id TEXT NOT NULL,
+    thread_id TEXT NOT NULL,
+    run_outcome TEXT NOT NULL,
+    queued_at INTEGER NOT NULL
+  )`;
+  yield* sql`CREATE INDEX project_knowledge_learning_queue_family
+    ON project_knowledge_learning_queue(project_id, root_thread_id, queued_at, run_id)`;
+});
diff --git a/apps/server/src/project/knowledge/AssistedLearning.test.ts b/apps/server/src/project/knowledge/AssistedLearning.test.ts
index cc231cce7aa75..b2ef4358861b4 100644
--- a/apps/server/src/project/knowledge/AssistedLearning.test.ts
+++ b/apps/server/src/project/knowledge/AssistedLearning.test.ts
@@ -22,6 +22,7 @@ import * as Hex from "effect/encoding/Hex";
 import * as Layer from "effect/Layer";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
+import * as TestClock from "effect/testing/TestClock";
 import * as SqlClient from "effect/sql/SqlClient";
 
 import * as ServerEnvironment from "../../environment/ServerEnvironment.ts";
@@ -59,7 +60,7 @@ const makeLayer = (
       Layer.mergeAll(ProjectStore.layer, ProjectionStore.layer, ThreadSearch.layer),
     ),
     Layer.provideMerge(SqlitePersistence.layerMemory),
-    Layer.provide(ServerSettings.layerTest(settings)),
+    Layer.provideMerge(ServerSettings.layerTest(settings)),
     Layer.provide(
       Layer.succeed(ServerEnvironment.ServerEnvironmentIdentity, {
         getEnvironmentId: Effect.succeed(EnvironmentId.make("learning-environment")),
@@ -272,12 +273,14 @@ it.effect("saves a settled run's cited facts exactly once, recallable without re
       {
         kind: "message",
         threadId,
+        runId,
         messageId: MessageId.make("learning-user"),
         digest: yield* sha256("From now on API responses use snake_case keys everywhere."),
       },
       {
         kind: "message",
         threadId,
+        runId,
         messageId: MessageId.make("learning-reply"),
         digest: yield* sha256("Done. I converted the handlers to snake_case keys."),
       },
@@ -458,9 +461,9 @@ it.effect(
 
 const testsCommand = {
   kind: "convention" as const,
-  content: "Tests run with vp test.",
+  content: "API field names use snake_case.",
   entities: [],
-  citations: ["M2"],
+  citations: ["M1"],
 };
 
 it.effect("does not bring back a forgotten fact when the job runs again", () => {
@@ -502,6 +505,7 @@ it.effect("commits a run's facts only together with its outcome", () => {
   const model = scripted([{ candidates: [snakeCase, testsCommand] }]);
   return Effect.gen(function* () {
     yield* seedRun;
+    yield* TestClock.setTime(DateTime.toEpochMillis(DateTime.add(at, { hours: 1 })));
     const runner = yield* AssistedLearningRunner;
     const knowledge = yield* ProjectKnowledge.ProjectKnowledge;
     const sql = yield* SqlClient.SqlClient;
@@ -510,14 +514,16 @@ it.effect("commits a run's facts only together with its outcome", () => {
     );
     yield* sql`CREATE TEMP TRIGGER lose_outcome BEFORE INSERT ON project_knowledge_assisted_runs
       BEGIN SELECT RAISE(ABORT, 'outcome lost'); END`;
-    const lost = yield* runner
-      .extractRun({ threadId, runId, runOutcome: "completed" })
-      .pipe(Effect.result);
+    yield* runner.enqueueRun({ threadId, runId, runOutcome: "completed" });
+    yield* TestClock.adjust("30 minutes");
+    const lost = yield* runner.drainDue.pipe(Effect.result);
     assert.isTrue(Result.isFailure(lost));
     // Nothing a user could edit or forget exists without the outcome.
     assert.deepEqual(yield* savedContent, []);
+    assert.equal((yield* sql`SELECT * FROM project_knowledge_learning_queue`).length, 1);
     yield* sql`DROP TRIGGER lose_outcome`;
-    yield* runner.extractRun({ threadId, runId, runOutcome: "completed" });
+    yield* runner.drainDue;
+    assert.deepEqual(yield* sql`SELECT * FROM project_knowledge_learning_queue`, []);
     assert.deepEqual(yield* savedContent, [snakeCase.content, testsCommand.content].toSorted());
     assert.equal((yield* knowledge.status({ projectId })).assistedLearning?.lastRun?.saved, 2);
   }).pipe(Effect.provide(makeLayer(model.generate)));
@@ -609,3 +615,355 @@ it.effect("skips a run whose project turned automatic memory off before it ran",
     ),
   );
 });
+
+it.effect(
+  "waits for family inactivity, resumes its durable queue, and never reviews old evidence twice",
+  () => {
+    const model = scripted([{ candidates: [snakeCase] }]);
+    return Effect.gen(function* () {
+      yield* seedRun;
+      yield* TestClock.setTime(DateTime.toEpochMillis(DateTime.add(at, { minutes: 10 })));
+      const runner = yield* AssistedLearningRunner;
+      const sql = yield* SqlClient.SqlClient;
+      yield* runner.enqueueRun({ threadId, runId, runOutcome: "completed" });
+      yield* runner.enqueueRun({ threadId, runId, runOutcome: "completed" });
+      yield* runner.drainDue;
+      assert.equal(model.calls.length, 0);
+      assert.equal((yield* sql`SELECT * FROM project_knowledge_learning_queue`).length, 1);
+      yield* TestClock.adjust("30 minutes");
+      yield* runner.drainDue;
+      assert.equal(model.calls.length, 1);
+      assert.deepEqual(yield* sql`SELECT * FROM project_knowledge_learning_queue`, []);
+      yield* runner.enqueueRun({ threadId, runId, runOutcome: "completed" });
+      yield* TestClock.adjust("30 minutes");
+      yield* runner.drainDue;
+      assert.equal(model.calls.length, 1);
+    }).pipe(Effect.provide(makeLayer(model.generate)));
+  },
+);
+
+it.effect(
+  "batches eight new runs across a root and its child, retaining each citation's provenance",
+  () => {
+    const model = scripted([
+      {
+        candidates: [
+          { ...snakeCase, citations: ["M1", "M8"] },
+          { ...testsCommand, citations: ["M2", "M3"] },
+        ],
+      },
+    ]);
+    return Effect.gen(function* () {
+      yield* seedRun;
+      yield* TestClock.setTime(DateTime.toEpochMillis(DateTime.add(at, { minutes: 10 })));
+      const runner = yield* AssistedLearningRunner;
+      const projections = yield* ProjectionStore.ProjectionStoreV2;
+      const records = yield* projections.getThreadRecords(threadId, []);
+      const childId = ThreadId.make("learning-child");
+      yield* projections.apply({
+        id: EventId.make("create-child"),
+        type: "thread.created",
+        threadId: childId,
+        providerInstanceId,
+        occurredAt: at,
+        payload: {
+          ...records.thread,
+          id: childId,
+          lineage: {
+            parentThreadId: threadId,
+            rootThreadId: threadId,
+            relationshipToParent: "subagent",
+          },
+        },
+      });
+      for (let index = 0; index < 8; index += 1) {
+        const sourceThreadId = index % 2 === 0 ? threadId : childId;
+        const sourceRunId = RunId.make(`batch-run-${index}`);
+        yield* projections.apply({
+          id: EventId.make(`batch-message-${index}`),
+          type: "message.updated",
+          threadId: sourceThreadId,
+          providerInstanceId,
+          occurredAt: DateTime.add(at, { minutes: index }),
+          payload: {
+            id: MessageId.make(`batch-message-${index}`),
+            threadId: sourceThreadId,
+            runId: sourceRunId,
+            nodeId: null,
+            role: index === 0 ? "user" : "assistant",
+            text: `API responses use snake_case keys ${index}.`,
+            attachments: [],
+            streaming: false,
+            createdAt: DateTime.add(at, { minutes: index }),
+            updatedAt: at,
+            createdBy: index === 0 ? "user" : "agent",
+            creationSource: "web",
+          },
+        });
+        yield* runner.enqueueRun({
+          threadId: sourceThreadId,
+          runId: sourceRunId,
+          runOutcome: "completed",
+        });
+        assert.equal(model.calls.length, 0);
+      }
+      yield* runner.drainDue;
+      assert.equal(model.calls.length, 1);
+      assert.equal(model.calls[0]!.messages.length, 8);
+      const knowledge = yield* ProjectKnowledge.ProjectKnowledge;
+      const { facts } = yield* knowledge.list({ projectId, status: "saved" });
+      assert.equal(facts.length, 2);
+      assert.deepEqual(
+        facts
+          .find((fact) => fact.content === snakeCase.content)!
+          .sources.map((source) => source.kind === "message" && [source.threadId, source.runId]),
+        [
+          [threadId, RunId.make("batch-run-0")],
+          [childId, RunId.make("batch-run-7")],
+        ],
+      );
+    }).pipe(Effect.provide(makeLayer(model.generate)));
+  },
+);
+
+it.effect("resets the idle window when the family receives new work", () => {
+  const model = scripted([{ candidates: [snakeCase] }]);
+  return Effect.gen(function* () {
+    yield* seedRun;
+    yield* TestClock.setTime(DateTime.toEpochMillis(DateTime.add(at, { minutes: 10 })));
+    const runner = yield* AssistedLearningRunner;
+    const projections = yield* ProjectionStore.ProjectionStoreV2;
+    yield* runner.enqueueRun({ threadId, runId, runOutcome: "completed" });
+    yield* TestClock.adjust("20 minutes");
+    const now = yield* DateTime.now;
+    yield* projections.apply({
+      id: EventId.make("new-family-work"),
+      type: "message.updated",
+      threadId,
+      providerInstanceId,
+      occurredAt: now,
+      payload: {
+        id: MessageId.make("new-family-work"),
+        threadId,
+        runId: RunId.make("next-run"),
+        nodeId: null,
+        role: "user",
+        text: "Continue working on the API.",
+        attachments: [],
+        streaming: false,
+        createdAt: now,
+        updatedAt: now,
+        createdBy: "user",
+        creationSource: "web",
+      },
+    });
+    yield* TestClock.adjust("10 minutes");
+    yield* runner.drainDue;
+    assert.equal(model.calls.length, 0);
+    yield* TestClock.adjust("20 minutes");
+    yield* runner.drainDue;
+    assert.equal(model.calls.length, 1);
+    assert.equal(model.calls[0]!.messages.length, 2);
+  }).pipe(Effect.provide(makeLayer(model.generate)));
+});
+
+it.effect(
+  "drops unsupported assistant-only claims and terminal model failures without a retry storm",
+  () => {
+    const model = scripted([
+      { candidates: [{ ...snakeCase, citations: ["M2"] }] },
+      new TextGenerationError({
+        operation: "generateKnowledgeCandidates",
+        detail: "Provider quota exhausted",
+      }),
+    ]);
+    return Effect.gen(function* () {
+      yield* seedRun;
+      const runner = yield* AssistedLearningRunner;
+      const knowledge = yield* ProjectKnowledge.ProjectKnowledge;
+      yield* runner.extractRun({ threadId, runId, runOutcome: "completed" });
+      assert.deepEqual((yield* knowledge.list({ projectId, status: "saved" })).facts, []);
+      const sql = yield* SqlClient.SqlClient;
+      yield* sql`DELETE FROM project_knowledge_assisted_runs`;
+      yield* TestClock.setTime(DateTime.toEpochMillis(DateTime.add(at, { hours: 1 })));
+      yield* runner.enqueueRun({ threadId, runId, runOutcome: "completed" });
+      yield* TestClock.adjust("30 minutes");
+      yield* runner.drainDue;
+      yield* TestClock.adjust("30 minutes");
+      yield* runner.drainDue;
+      assert.equal(model.calls.length, 2);
+      assert.equal(
+        (yield* knowledge.status({ projectId })).assistedLearning?.lastRun?.result,
+        "failed",
+      );
+      assert.deepEqual(yield* sql`SELECT * FROM project_knowledge_learning_queue`, []);
+    }).pipe(Effect.provide(makeLayer(model.generate)));
+  },
+);
+
+it.effect(
+  "receipts bounded pending chunks when a project opts out, without reading them into a model",
+  () => {
+    const model = scripted([{ candidates: [snakeCase] }]);
+    return Effect.gen(function* () {
+      yield* seedRun;
+      const runner = yield* AssistedLearningRunner;
+      yield* runner.enqueueRun({ threadId, runId, runOutcome: "completed" });
+      const sql = yield* SqlClient.SqlClient;
+      for (let index = 0; index < 9; index += 1)
+        yield* sql`INSERT INTO project_knowledge_learning_queue
+        (project_id, root_thread_id, thread_id, run_id, run_outcome, queued_at)
+        VALUES (${projectId}, ${threadId}, ${threadId}, ${`opt-out-${index}`}, 'completed', 0)`;
+      const settings = yield* ServerSettings.ServerSettingsService;
+      yield* settings.updateSettings({
+        projectSettingsOverrides: { [projectId]: { enableAssistedLearning: false } },
+      });
+      yield* runner.drainDue;
+      assert.equal(model.calls.length, 0);
+      const knowledge = yield* ProjectKnowledge.ProjectKnowledge;
+      assert.equal(
+        (yield* knowledge.status({ projectId })).assistedLearning?.lastRun?.result,
+        "skipped",
+      );
+      assert.equal((yield* sql`SELECT * FROM project_knowledge_learning_queue`).length, 2);
+      assert.equal((yield* sql`SELECT * FROM project_knowledge_assisted_runs`).length, 8);
+      yield* runner.drainDue;
+      assert.deepEqual(yield* sql`SELECT * FROM project_knowledge_learning_queue`, []);
+    }).pipe(Effect.provide(makeLayer(model.generate)));
+  },
+);
+
+it.effect("resumes a persisted idle family after restart without a new run event", () => {
+  const model = scripted([{ candidates: [snakeCase] }]);
+  return Effect.gen(function* () {
+    yield* seedRun;
+    yield* TestClock.setTime(DateTime.toEpochMillis(DateTime.add(at, { hours: 1 })));
+    const sql = yield* SqlClient.SqlClient;
+    yield* sql`INSERT INTO project_knowledge_learning_queue
+      (project_id, root_thread_id, thread_id, run_id, run_outcome, queued_at)
+      VALUES (${projectId}, ${threadId}, ${threadId}, ${runId}, 'completed', ${DateTime.toEpochMillis(at)})`;
+    const runner = yield* AssistedLearningRunner;
+    yield* runner.drainDue;
+    yield* runner.drainDue;
+    assert.equal(model.calls.length, 1);
+    const knowledge = yield* ProjectKnowledge.ProjectKnowledge;
+    assert.equal((yield* knowledge.list({ projectId, status: "saved" })).facts.length, 1);
+    assert.deepEqual(yield* sql`SELECT * FROM project_knowledge_learning_queue`, []);
+  }).pipe(Effect.provide(makeLayer(model.generate)));
+});
+
+it.effect.each(["missing", "deleted", "moved"] as const)(
+  "consumes a %s queue head and attributes sibling facts to their interrupted source run",
+  (state) => {
+    const model = scripted([{ candidates: [snakeCase] }]);
+    return Effect.gen(function* () {
+      yield* seedRun;
+      yield* TestClock.setTime(DateTime.toEpochMillis(DateTime.add(at, { hours: 1 })));
+      const sql = yield* SqlClient.SqlClient;
+      const missingRun = RunId.make("missing-run");
+      if (state !== "missing") {
+        const projections = yield* ProjectionStore.ProjectionStoreV2;
+        const records = yield* projections.getThreadRecords(threadId, []);
+        yield* projections.apply({
+          id: EventId.make("unavailable-head"),
+          type: "thread.created",
+          threadId: ThreadId.make("missing-thread"),
+          providerInstanceId,
+          occurredAt: at,
+          payload: {
+            ...records.thread,
+            id: ThreadId.make("missing-thread"),
+            projectId: state === "moved" ? ProjectId.make("another-project") : projectId,
+            deletedAt: state === "deleted" ? at : null,
+          },
+        });
+      }
+      yield* sql`INSERT INTO project_knowledge_learning_queue
+      (project_id, root_thread_id, thread_id, run_id, run_outcome, queued_at) VALUES
+      (${projectId}, ${threadId}, 'missing-thread', ${missingRun}, 'failed', 0),
+      (${projectId}, ${threadId}, ${threadId}, ${runId}, 'interrupted', 1)`;
+      const runner = yield* AssistedLearningRunner;
+      yield* runner.drainDue;
+      const knowledge = yield* ProjectKnowledge.ProjectKnowledge;
+      const { facts } = yield* knowledge.list({ projectId, status: "saved" });
+      assert.equal(facts.length, 1);
+      assert.deepEqual(facts[0]!.origin, {
+        kind: "assisted",
+        threadId,
+        runId,
+        runOutcome: "interrupted",
+      });
+      assert.deepEqual(
+        yield* sql`SELECT run_id, result, saved FROM project_knowledge_assisted_runs ORDER BY run_id`,
+        [
+          { run_id: runId, result: "ran", saved: 1 },
+          { run_id: missingRun, result: "skipped", saved: 0 },
+        ],
+      );
+      assert.deepEqual(yield* sql`SELECT * FROM project_knowledge_learning_queue`, []);
+      assert.equal(model.calls[0]!.messages[0]!.runOutcome, "interrupted");
+    }).pipe(Effect.provide(makeLayer(model.generate)));
+  },
+);
+
+it.effect(
+  "avoids a model call for uncorroborated assistant-only evidence and caps every transcript slice",
+  () => {
+    const model = scripted([{ candidates: [] }]);
+    return Effect.gen(function* () {
+      yield* seedRun;
+      const sql = yield* SqlClient.SqlClient;
+      yield* sql`UPDATE orchestration_v2_projection_messages SET payload_json = json_set(payload_json, '$.createdBy', 'agent') WHERE message_id = 'learning-user'`;
+      const runner = yield* AssistedLearningRunner;
+      yield* runner.extractRun({ threadId, runId, runOutcome: "completed" });
+      assert.equal(model.calls.length, 0);
+      yield* sql`DELETE FROM project_knowledge_assisted_runs`;
+      yield* sql`UPDATE orchestration_v2_projection_messages SET payload_json = json_set(payload_json, '$.createdBy', 'user') WHERE message_id = 'learning-user'`;
+      yield* seedReplies(10);
+      yield* sql`UPDATE orchestration_v2_projection_messages SET payload_json = json_set(payload_json, '$.text', ${"x".repeat(6_000)}) WHERE role = 'assistant'`;
+      yield* runner.extractRun({ threadId, runId, runOutcome: "completed" });
+      assert.equal(model.calls.length, 1);
+      assert.isAtMost(
+        model.calls[0]!.messages.reduce((total, message) => total + message.text.length, 0),
+        32_000,
+      );
+      assert.isTrue(model.calls[0]!.messages.every((message) => message.text.length <= 6_000));
+    }).pipe(Effect.provide(makeLayer(model.generate)));
+  },
+);
+
+it.effect.each([" OK! ", "Thanks.", "continue...", "HELLO", "Use Bun."])(
+  "requires meaningful human evidence before paying for a singleton review: %s",
+  (text) => {
+    const model = scripted([{ candidates: [] }]);
+    return Effect.gen(function* () {
+      yield* seedRun;
+      const sql = yield* SqlClient.SqlClient;
+      yield* sql`UPDATE orchestration_v2_projection_messages SET payload_json = json_set(payload_json, '$.text', ${text}) WHERE message_id = 'learning-user'`;
+      const runner = yield* AssistedLearningRunner;
+      yield* runner.extractRun({ threadId, runId, runOutcome: "completed" });
+      assert.equal(model.calls.length, text === "Use Bun." ? 1 : 0);
+    }).pipe(Effect.provide(makeLayer(model.generate)));
+  },
+);
+
+it.effect("dequeues stale completed entries without touching their existing receipts", () => {
+  const model = scripted([{ candidates: [snakeCase] }]);
+  return Effect.gen(function* () {
+    yield* seedRun;
+    const runner = yield* AssistedLearningRunner;
+    yield* runner.extractRun({ threadId, runId, runOutcome: "completed" });
+    const sql = yield* SqlClient.SqlClient;
+    const before = yield* sql`SELECT * FROM project_knowledge_assisted_runs`;
+    yield* runner.enqueueRun({ threadId, runId, runOutcome: "failed" });
+    assert.deepEqual(yield* sql`SELECT * FROM project_knowledge_learning_queue`, []);
+    yield* sql`INSERT INTO project_knowledge_learning_queue
+      (project_id, root_thread_id, thread_id, run_id, run_outcome, queued_at)
+      VALUES (${projectId}, ${threadId}, ${threadId}, ${runId}, 'failed', 0)`;
+    yield* TestClock.setTime(DateTime.toEpochMillis(DateTime.add(at, { hours: 1 })));
+    yield* runner.drainDue;
+    assert.deepEqual(yield* sql`SELECT * FROM project_knowledge_assisted_runs`, before);
+    assert.deepEqual(yield* sql`SELECT * FROM project_knowledge_learning_queue`, []);
+    assert.equal(model.calls.length, 1);
+  }).pipe(Effect.provide(makeLayer(model.generate)));
+});
diff --git a/apps/server/src/project/knowledge/AssistedLearning.ts b/apps/server/src/project/knowledge/AssistedLearning.ts
index c224f63d74ed6..0a4b90b5bf2f6 100644
--- a/apps/server/src/project/knowledge/AssistedLearning.ts
+++ b/apps/server/src/project/knowledge/AssistedLearning.ts
@@ -5,6 +5,9 @@ import {
   type AssistedLearningRun,
   type KnowledgeMessageRef,
   type ProjectId,
+  RunId,
+  ThreadId,
+  AssistedLearningRunOutcome,
 } from "@t3tools/contracts";
 import { resolveProjectSettings } from "@t3tools/shared/projectSettings";
 import * as Digest from "effect/crypto/Digest";
@@ -14,8 +17,11 @@ import * as Hex from "effect/encoding/Hex";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
+import * as Semaphore from "effect/Semaphore";
 import * as SqlClient from "effect/sql/SqlClient";
 
+import { forkParked } from "../../serverActivation.ts";
+
 import * as ProjectStore from "../../orchestration-v2/ProjectStore.ts";
 import * as ProjectionStore from "../../orchestration-v2/ProjectionStore.ts";
 import * as ServerSettings from "../../serverSettings.ts";
@@ -33,6 +39,35 @@ const MAX_TRANSCRIPT_CHARS = 32_000;
 const MAX_CANDIDATES = 3;
 const MAX_CANDIDATE_CHARS = 2_000;
 const MAX_ENTITIES = 5;
+const ACKNOWLEDGEMENTS = new Set([
+  "ok",
+  "okay",
+  "thanks",
+  "thank you",
+  "continue",
+  "go on",
+  "proceed",
+  "hi",
+  "hello",
+  "hey",
+  "next",
+  "yes",
+  "yep",
+  "sure",
+  "sounds good",
+  "great",
+  "nice",
+  "done",
+  "go ahead",
+]);
+const supportsLearning = (text: string) =>
+  !ACKNOWLEDGEMENTS.has(
+    text
+      .trim()
+      .toLowerCase()
+      .replace(/[.!?…]+$/gu, "")
+      .trim(),
+  );
 
 const Candidate = Schema.Struct({
   kind: Schema.Literals(["decision", "constraint", "convention"]),
@@ -54,33 +89,41 @@ const make = Effect.gen(function* () {
   const digest = (text: string) =>
     crypto.digest(Digest.sha256, new TextEncoder().encode(text)).pipe(Effect.map(Hex.encode));
 
-  const extractRun: AssistedLearningRunnerShape["extractRun"] = Effect.fn(
-    "AssistedLearning.extractRun",
-  )(
-    function* ({ threadId, runId, runOutcome }) {
-      const records = yield* projections
-        // The run's request and its replies both carry the run id.
-        .getThreadRecords(threadId, ["messages"], { messageRunIds: [runId] })
-        .pipe(Effect.catchTags({ ProjectionStoreThreadNotFoundError: () => Effect.succeed(null) }));
-      // With no thread there is no project to attribute an outcome to.
-      if (records === null) return;
-      const projectId: ProjectId = records.thread.projectId;
-      if (yield* knowledge.hasAssistedRun(projectId, runId)) return;
-      const finish = (result: AssistedLearningRun["result"], reason: string | null, saved = 0) =>
-        DateTime.now.pipe(
-          Effect.flatMap((now) =>
-            knowledge.recordAssistedRun(projectId, {
-              threadId,
-              runId,
-              runOutcome,
-              result,
-              reason,
-              saved,
-              at: DateTime.formatIso(now),
-            }),
-          ),
+  const lock = yield* Semaphore.make(1);
+  const extractBatch = Effect.fn("AssistedLearning.extractRun")(
+    function* (
+      projectId: ProjectId,
+      scheduledBatch: ReadonlyArray<Parameters<AssistedLearningRunnerShape["extractRun"]>[0]>,
+      rootThreadId?: ThreadId,
+    ) {
+      const batch: Array<Parameters<AssistedLearningRunnerShape["extractRun"]>[0]> = [];
+      for (const entry of scheduledBatch) {
+        if (yield* knowledge.hasAssistedRun(projectId, entry.runId)) {
+          yield* sql`DELETE FROM project_knowledge_learning_queue WHERE run_id = ${entry.runId}`;
+        } else batch.push(entry);
+      }
+      if (batch.length === 0) return;
+      const savedByRun = new Map<RunId, number>();
+      const skippedRuns = new Set<RunId>();
+      const finish = (result: AssistedLearningRun["result"], reason: string | null) =>
+        sql.withTransaction(
+          Effect.gen(function* () {
+            const at = DateTime.formatIso(yield* DateTime.now);
+            for (const entry of batch) {
+              if (!(yield* knowledge.hasAssistedRun(projectId, entry.runId)))
+                yield* knowledge.recordAssistedRun(projectId, {
+                  ...entry,
+                  result: skippedRuns.has(entry.runId) ? "skipped" : result,
+                  reason: skippedRuns.has(entry.runId)
+                    ? "The source thread is unavailable or moved."
+                    : reason,
+                  saved: savedByRun.get(entry.runId) ?? 0,
+                  at,
+                });
+              yield* sql`DELETE FROM project_knowledge_learning_queue WHERE run_id = ${entry.runId}`;
+            }
+          }),
         );
-      if (records.thread.deletedAt !== null) return yield* finish("skipped", "Thread was deleted.");
       const settings = resolveProjectSettings(
         yield* serverSettings.getSettings,
         projectId,
@@ -88,59 +131,110 @@ const make = Effect.gen(function* () {
       // The setting can change between scheduling and running; the latest choice wins.
       if (!settings.enableAssistedLearning)
         return yield* finish("skipped", "Automatic memory is off for this project.");
-      const finalized = records.messages
-        .filter(
-          (message) =>
-            (message.role === "user" || message.role === "assistant") &&
-            !message.streaming &&
-            message.text.trim() !== "",
-        )
-        .toSorted(
-          (left, right) =>
-            DateTime.toEpochMillis(left.createdAt) - DateTime.toEpochMillis(right.createdAt),
+      const evidence = [];
+      for (const entry of batch) {
+        if (yield* knowledge.hasAssistedRun(projectId, entry.runId)) continue;
+        const source = yield* projections
+          .getThreadRecords(entry.threadId, ["messages"], { messageRunIds: [entry.runId] })
+          .pipe(
+            Effect.catchTags({ ProjectionStoreThreadNotFoundError: () => Effect.succeed(null) }),
+          );
+        if (
+          source === null ||
+          source.thread.projectId !== projectId ||
+          (rootThreadId !== undefined && source.thread.lineage.rootThreadId !== rootThreadId) ||
+          source.thread.deletedAt !== null
+        ) {
+          skippedRuns.add(entry.runId);
+          continue;
+        }
+        evidence.push(
+          ...source.messages.filter(
+            (message) =>
+              (message.role === "user" || message.role === "assistant") &&
+              !message.streaming &&
+              message.text.trim() !== "",
+          ),
         );
+      }
+      const finalized = evidence.toSorted(
+        (left, right) =>
+          DateTime.toEpochMillis(left.createdAt) - DateTime.toEpochMillis(right.createdAt),
+      );
       if (!finalized.some((message) => message.role === "assistant"))
         return yield* finish("skipped", "The run has no finished reply to learn from.");
+      const userEvidence = finalized.some(
+        (message) =>
+          message.role === "user" && message.createdBy === "user" && supportsLearning(message.text),
+      );
+      const completedEvidence = finalized.filter((message) =>
+        batch.some((entry) => entry.runId === message.runId && entry.runOutcome === "completed"),
+      );
+      if (
+        !userEvidence &&
+        (new Set(completedEvidence.map((message) => message.runId)).size < 2 ||
+          new Set(completedEvidence.map((message) => message.threadId)).size < 2 ||
+          new Set(completedEvidence.map((message) => message.text.trim().toLowerCase())).size < 2)
+      )
+        return yield* finish(
+          "skipped",
+          "No user-supported or independently corroborated evidence.",
+        );
       // Keep the request and the latest replies; the middle of a long run goes first.
       const kept: typeof finalized = [];
+      const textLimits = new Map<string, number>();
       let budget = MAX_TRANSCRIPT_CHARS;
       for (const message of [finalized[0]!, ...finalized.slice(1).toReversed()]) {
         if (kept.length >= MAX_MESSAGES || budget <= 0) break;
+        const available = Math.min(budget, MAX_MESSAGE_CHARS);
         kept.push(message);
-        budget -= Math.min(message.text.length, MAX_MESSAGE_CHARS);
+        textLimits.set(message.id, available);
+        budget -= Math.min(message.text.length, available);
       }
       const transcript = kept.toSorted(
         (left, right) => finalized.indexOf(left) - finalized.indexOf(right),
       );
       // Citations are message ids and digests from this canonical read; the model only names refs.
       const refs = new Map<string, KnowledgeMessageRef>();
-      const messages = [];
+      const userRefs = new Set<string>();
+      const messages: Array<
+        TextGeneration.KnowledgeCandidatesGenerationInput["messages"][number] & {
+          threadId: ThreadId;
+          runId: RunId;
+          runOutcome: AssistedLearningRunOutcome;
+        }
+      > = [];
       for (const [index, message] of transcript.entries()) {
         const ref = `M${index + 1}`;
+        if (
+          message.role === "user" &&
+          message.createdBy === "user" &&
+          supportsLearning(message.text)
+        )
+          userRefs.add(ref);
         refs.set(ref, {
           kind: "message",
-          threadId,
+          threadId: message.threadId,
+          runId: message.runId!,
           messageId: message.id,
           digest: yield* digest(message.text),
         });
         messages.push({
           ref,
           role: message.role as "user" | "assistant",
-          text:
-            message.text.length > MAX_MESSAGE_CHARS
-              ? `${message.text.slice(0, MAX_MESSAGE_CHARS)}\n[truncated]`
-              : message.text,
+          threadId: message.threadId,
+          runId: message.runId!,
+          runOutcome: batch.find((entry) => entry.runId === message.runId)!.runOutcome,
+          text: message.text.slice(0, textLimits.get(message.id)),
         });
       }
       const project = yield* projects.get(projectId);
-      const cwd =
-        records.thread.worktreePath ??
-        (Option.isSome(project) ? project.value.workspaceRoot : undefined);
+      const cwd = Option.isSome(project) ? project.value.workspaceRoot : undefined;
       if (cwd === undefined) return yield* finish("skipped", "The project was not found.");
       const generated = yield* textGeneration
         .generateKnowledgeCandidates({
           cwd,
-          runOutcome,
+          runOutcome: batch.length === 1 ? batch[0]!.runOutcome : "completed",
           messages,
           modelSelection: settings.textGenerationModelSelection,
         })
@@ -152,10 +246,19 @@ const make = Effect.gen(function* () {
           }),
         );
       if (!generated.ok) return yield* finish("failed", generated.detail.slice(0, 300));
-      const actor = { kind: "assisted" as const, threadId, runId, runOutcome };
       yield* sql.withTransaction(
         Effect.gen(function* () {
-          if (yield* knowledge.hasAssistedRun(projectId, runId)) return;
+          if (
+            (yield* Effect.forEach(batch, (entry) =>
+              knowledge.hasAssistedRun(projectId, entry.runId),
+            )).every(Boolean)
+          )
+            return;
+          if (
+            !resolveProjectSettings(yield* serverSettings.getSettings, projectId).settings
+              .enableAssistedLearning
+          )
+            return yield* finish("skipped", "Automatic memory is off for this project.");
           let saved = 0;
           let duplicates = 0;
           let dropped = 0;
@@ -167,11 +270,36 @@ const make = Effect.gen(function* () {
               const source = refs.get(ref);
               return source ? [source] : [];
             });
-            if (candidate === null || sources.length === 0) {
+            const citedMessages = messages.filter((message) =>
+              (candidate?.citations ?? []).some((ref) => ref.trim() === message.ref),
+            );
+            const corroborated =
+              citedMessages.every((message) => message.runOutcome === "completed") &&
+              new Set(citedMessages.map((message) => message.runId)).size >= 2 &&
+              new Set(citedMessages.map((message) => message.threadId)).size >= 2 &&
+              new Set(citedMessages.map((message) => message.text.trim().toLowerCase())).size >= 2;
+            const userSupported = (candidate?.citations ?? []).some((ref) =>
+              userRefs.has(ref.trim()),
+            );
+            if (
+              candidate === null ||
+              sources.length === 0 ||
+              candidate.citations.some((ref) => !refs.has(ref.trim())) ||
+              (!userSupported && !corroborated)
+            ) {
               dropped += 1;
               continue;
             }
-            const runContentId = `assisted:${runId}:${(yield* digest(candidate.content)).slice(0, 32)}`;
+            const support =
+              citedMessages.find((message) => userRefs.has(message.ref)) ?? citedMessages[0]!;
+            const actor = {
+              kind: "assisted" as const,
+              threadId: support.threadId,
+              runId: support.runId,
+              runOutcome: support.runOutcome,
+            };
+            if (yield* knowledge.hasAssistedRun(projectId, actor.runId)) continue;
+            const runContentId = `assisted:${actor.runId}:${(yield* digest(candidate.content)).slice(0, 32)}`;
             const create = {
               action: "create" as const,
               commandId: CommandId.make(runContentId),
@@ -201,8 +329,10 @@ const make = Effect.gen(function* () {
                     : Effect.succeed({ outcome: "dropped" as const }),
               }),
             );
-            if (result.outcome === "saved") saved += 1;
-            else if (result.outcome === "duplicate") duplicates += 1;
+            if (result.outcome === "saved") {
+              saved += 1;
+              savedByRun.set(actor.runId, (savedByRun.get(actor.runId) ?? 0) + 1);
+            } else if (result.outcome === "duplicate") duplicates += 1;
             else if (result.outcome === "dropped") dropped += 1;
           }
           const notes = [
@@ -218,16 +348,135 @@ const make = Effect.gen(function* () {
           yield* finish(
             "ran",
             notes.length > 0 ? notes.join(" ") : saved === 0 ? "Nothing durable to save." : null,
-            saved,
           );
         }),
       );
     },
+    (effect, _projectId, batch, _rootThreadId) =>
+      effect.pipe(
+        Effect.mapError((cause) => new AssistedLearningError({ runId: batch[0]!.runId, cause })),
+      ),
+  );
+
+  const extractRun: AssistedLearningRunnerShape["extractRun"] = Effect.fn(
+    "AssistedLearning.extractSingleRun",
+  )(
+    function* (input) {
+      const records = yield* projections
+        .getThreadRecords(input.threadId, [])
+        .pipe(Effect.catchTags({ ProjectionStoreThreadNotFoundError: () => Effect.succeed(null) }));
+      if (records !== null)
+        yield* extractBatch(records.thread.projectId, [input], records.thread.lineage.rootThreadId);
+    },
     (effect, { runId }) =>
       effect.pipe(Effect.mapError((cause) => new AssistedLearningError({ runId, cause }))),
   );
-
-  return { extractRun };
+  const decodeQueue = Schema.decodeUnknownEffect(
+    Schema.Array(
+      Schema.Struct({
+        threadId: ThreadId,
+        runId: RunId,
+        runOutcome: AssistedLearningRunOutcome,
+      }),
+    ),
+  );
+  const drainDue = lock
+    .withPermits(1)(
+      Effect.gen(function* () {
+        const now = DateTime.toEpochMillis(yield* DateTime.now);
+        const families = yield* sql<{
+          projectId: ProjectId;
+          rootThreadId: ThreadId;
+          completed: number;
+          lastQueuedAt: number;
+        }>`
+      SELECT project_id AS "projectId", root_thread_id AS "rootThreadId",
+        SUM(CASE WHEN run_outcome = 'completed' THEN 1 ELSE 0 END) AS completed,
+        MAX(queued_at) AS "lastQueuedAt"
+      FROM project_knowledge_learning_queue GROUP BY project_id, root_thread_id`;
+        if (families.length === 0) return;
+        const settings = yield* serverSettings.getSettings;
+        for (const family of families) {
+          const enabled = resolveProjectSettings(settings, family.projectId).settings
+            .enableAssistedLearning;
+          if (enabled && family.completed < 8) {
+            if (family.lastQueuedAt > now - 30 * 60 * 1000) continue;
+            const shells = yield* projections.getShellSnapshot({
+              familyOf: family.rootThreadId,
+              projectId: family.projectId,
+            });
+            const members = [...shells.threads, ...shells.archivedThreads];
+            const busy = members.some(
+              (thread) =>
+                thread.activeRunId !== null ||
+                thread.activityRunStatus != null ||
+                thread.pendingRuntimeRequest !== null,
+            );
+            const latestActivity = members.reduce(
+              (latest, thread) =>
+                Math.max(
+                  latest,
+                  ...[
+                    thread.latestVisibleMessage?.updatedAt,
+                    thread.latestUserMessageAt,
+                    thread.latestRunRequestedAt,
+                    thread.latestRunCompletedAt,
+                  ].flatMap((at) => (at == null ? [] : [DateTime.toEpochMillis(at)])),
+                ),
+              family.lastQueuedAt,
+            );
+            if (busy || latestActivity > now - 30 * 60 * 1000) continue;
+          }
+          const batch = yield* sql`
+        SELECT thread_id AS "threadId", run_id AS "runId", run_outcome AS "runOutcome"
+        FROM project_knowledge_learning_queue WHERE project_id = ${family.projectId}
+          AND root_thread_id = ${family.rootThreadId} ORDER BY queued_at, run_id LIMIT 8
+      `.pipe(Effect.flatMap(decodeQueue));
+          if (batch.length > 0) yield* extractBatch(family.projectId, batch, family.rootThreadId);
+        }
+      }),
+    )
+    .pipe(
+      Effect.mapError((cause) => new AssistedLearningError({ runId: "learning-queue", cause })),
+    );
+  const enqueueRun: AssistedLearningRunnerShape["enqueueRun"] = Effect.fn(
+    "AssistedLearning.enqueueRun",
+  )(
+    function* (input) {
+      const records = yield* projections
+        .getThreadRecords(input.threadId, [])
+        .pipe(Effect.catchTags({ ProjectionStoreThreadNotFoundError: () => Effect.succeed(null) }));
+      if (records === null) return;
+      const now = DateTime.toEpochMillis(yield* DateTime.now);
+      yield* sql`INSERT INTO project_knowledge_learning_queue
+        (run_id, project_id, root_thread_id, thread_id, run_outcome, queued_at)
+        SELECT ${input.runId}, ${records.thread.projectId}, ${records.thread.lineage.rootThreadId},
+          ${input.threadId}, ${input.runOutcome}, ${now}
+        WHERE NOT EXISTS (SELECT 1 FROM project_knowledge_assisted_runs WHERE run_id = ${input.runId})
+        ON CONFLICT (run_id) DO NOTHING`;
+    },
+    (effect, { runId }) =>
+      effect.pipe(Effect.mapError((cause) => new AssistedLearningError({ runId, cause }))),
+  );
+  return { extractRun, enqueueRun, drainDue };
 });
 
 export const layerRunner = Layer.effect(AssistedLearningRunner, make);
+
+export const layerWorker = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const runner = yield* AssistedLearningRunner;
+    yield* forkParked(
+      Effect.forever(
+        Effect.gen(function* () {
+          yield* runner.drainDue.pipe(
+            Effect.catch((cause) =>
+              Effect.logWarning("Automatic memory review deferred", { cause }),
+            ),
+          );
+          yield* Effect.sleep("1 minute");
+        }),
+      ),
+    );
+  }),
+).pipe(Layer.provideMerge(layerRunner));
diff --git a/apps/server/src/project/knowledge/ProjectKnowledge.test.ts b/apps/server/src/project/knowledge/ProjectKnowledge.test.ts
index a709b2fafeb6d..6ec3e670c903c 100644
--- a/apps/server/src/project/knowledge/ProjectKnowledge.test.ts
+++ b/apps/server/src/project/knowledge/ProjectKnowledge.test.ts
@@ -60,14 +60,21 @@ import * as ProjectKnowledge from "./ProjectKnowledge.ts";
 const decodeKnowledgeSearchResult = Schema.decodeUnknownEffect(ProjectKnowledgeSearchResult);
 
 const environmentId = EnvironmentId.make("knowledge-test-environment");
-const knowledgeTestLayer = (scoring: typeof HolographicMemory.layer = HolographicMemory.layer) =>
+const knowledgeTestLayer = (
+  scoring: typeof HolographicMemory.layer = HolographicMemory.layer,
+  noTranscriptSearch = false,
+) =>
   ProjectKnowledge.layer.pipe(
     Layer.provide(scoring),
     Layer.provideMerge(
       Layer.mergeAll(
         ProjectStore.layer,
         ProjectionStore.layer,
-        ThreadSearch.layer,
+        noTranscriptSearch
+          ? Layer.mock(ThreadSearch.ThreadSearch)({
+              search: () => Effect.die("Passive previews must not search transcripts"),
+            })
+          : ThreadSearch.layer,
         ProjectionReplay.layer.pipe(
           Layer.provideMerge(EventStore.layer),
           Layer.provide(ProjectionStore.layer),
@@ -1733,6 +1740,62 @@ it.effect("browsing searches can opt out of reinforcing retrieval counts", () =>
       knowledge.list({ projectId }),
       (listed) => listed.facts[0]?.retrievalCount,
     );
+    assert.deepEqual(
+      yield* knowledge.suggest({
+        projectId,
+        requestId: CommandId.make("suggest-greeting"),
+        query: "hello there",
+      }),
+      [],
+    );
+    const suggestions = yield* knowledge.suggest({
+      projectId,
+      requestId: CommandId.make("suggest-relevant"),
+      query: "cache keys tenant",
+    });
+    assert.equal(suggestions.length, 1);
+    assert.equal(suggestions[0]?.fact.id, ProjectFactId.make("fact-one"));
+    assert.equal(suggestions[0]?.fact.sources[0]?.kind, "user");
+    const sql = yield* SqlClient.SqlClient;
+    assert.equal(
+      (yield* sql`SELECT command_id FROM project_knowledge_commands WHERE command_id = ${"suggest-relevant"}`)
+        .length,
+      0,
+    );
+
+    assert.deepEqual(
+      yield* knowledge.suggest({
+        projectId,
+        requestId: CommandId.make("suggest-weak"),
+        query: "tenant garden bicycle banana weather holiday mountain sunset",
+      }),
+      [],
+    );
+    yield* knowledge.mutate(
+      {
+        ...createFact(projectId, "unicode"),
+        content: "缓存键必须包含租户标识",
+        entities: [],
+        tags: [],
+      },
+      { kind: "user" },
+    );
+    const unicode = yield* knowledge.suggest({
+      projectId,
+      requestId: CommandId.make("suggest-unicode"),
+      query: "缓存键必须包含租户标识",
+    });
+    assert.equal(unicode[0]?.fact.id, ProjectFactId.make("unicode"));
+    assert.include(unicode[0]?.reason ?? "", "缓存键必须包含租户标识");
+    assert.deepEqual(
+      yield* knowledge.suggest({
+        projectId,
+        requestId: CommandId.make("suggest-filler"),
+        query: "please can you help",
+      }),
+      [],
+    );
+    assert.equal(yield* storedCount, 0);
     assert.equal(yield* searchCount("browse", false), 0);
     assert.equal(yield* storedCount, 0);
     assert.equal(yield* searchCount("agent"), 1);
@@ -2620,3 +2683,129 @@ it.effect(
       );
     }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
 );
+
+it.effect("automatic corroboration appends validated sources without rewriting curated facts", () =>
+  Effect.gen(function* () {
+    const knowledge = yield* ProjectKnowledge.ProjectKnowledge;
+    const projections = yield* ProjectionStore.ProjectionStoreV2;
+    const projectId = ProjectId.make("corroboration");
+    const threadId = ThreadId.make("corroboration-thread");
+    yield* createProject(projectId);
+    yield* projections.apply(thread(threadId, projectId));
+    yield* projections.apply(
+      message(threadId, "corroboration-source", "user", "Cache keys include tenant IDs."),
+    );
+    const citation = yield* knowledge.readSource({
+      projectId,
+      threadId,
+      messageId: MessageId.make("corroboration-source"),
+    });
+    assert.equal(citation.state, "available");
+    if (citation.state !== "available") return;
+    const original = yield* knowledge.mutate(createFact(projectId), { kind: "user" });
+    const actor = {
+      kind: "assisted" as const,
+      threadId,
+      runId: RunId.make("corroboration-run"),
+      runOutcome: "completed" as const,
+    };
+    const candidate = { ...createFact(projectId, "automatic"), sources: [citation.source] };
+    assert.equal((yield* knowledge.saveAutomatic(candidate, actor)).outcome, "duplicate");
+    const merged = (yield* knowledge.readFact({ projectId, factId: original.id })).fact;
+    assert.deepEqual(merged.sources, [...original.sources, citation.source]);
+    assert.equal(merged.content, original.content);
+    assert.deepEqual(merged.origin, original.origin);
+    assert.equal(merged.trust, original.trust);
+    yield* knowledge.saveAutomatic(
+      { ...candidate, factId: ProjectFactId.make("automatic-repeat") },
+      actor,
+    );
+    assert.deepEqual((yield* knowledge.readFact({ projectId, factId: original.id })).fact, merged);
+    const invalid = yield* knowledge
+      .saveAutomatic(
+        {
+          ...candidate,
+          factId: ProjectFactId.make("automatic-invalid"),
+          sources: [{ ...citation.source, runId: RunId.make("fabricated") }],
+        },
+        actor,
+      )
+      .pipe(Effect.result);
+    assert.equal(invalid._tag, "Failure");
+    const extraSources = [];
+    for (let index = 0; index < 16; index++) {
+      const id = MessageId.make(`corroboration-extra-${index}`);
+      yield* projections.apply(message(threadId, id, "user", "Cache keys include tenant IDs."));
+      const source = yield* knowledge.readSource({ projectId, threadId, messageId: id });
+      if (source.state === "available") extraSources.push(source.source);
+    }
+    yield* knowledge.saveAutomatic(
+      { ...candidate, factId: ProjectFactId.make("automatic-cap"), sources: extraSources },
+      actor,
+    );
+    const capped = (yield* knowledge.readFact({ projectId, factId: original.id })).fact;
+    assert.equal(capped.sources.length, 16);
+    assert.deepEqual(capped.sources.slice(0, 2), merged.sources);
+    yield* knowledge.mutate(
+      {
+        action: "forget",
+        projectId,
+        factId: original.id,
+        expectedRevision: capped.revision,
+        commandId: CommandId.make("forget-corroborated"),
+      },
+      { kind: "user" },
+    );
+    yield* knowledge.saveAutomatic({ ...candidate, factId: original.id }, actor);
+    assert.equal(
+      (yield* knowledge.readFact({ projectId, factId: original.id })).fact.status,
+      "forgotten",
+    );
+  }).pipe(Effect.provide(layerTest)),
+);
+
+it.effect("passive previews return only two relevant facts and never search transcripts", () =>
+  Effect.gen(function* () {
+    const knowledge = yield* ProjectKnowledge.ProjectKnowledge;
+    const projectId = ProjectId.make("compact-preview");
+    yield* createProject(projectId);
+    const empty = yield* knowledge.search({
+      projectId,
+      requestId: CommandId.make("preview-empty"),
+      query: "cache keys tenant",
+      preview: true,
+    });
+    assert.deepEqual(empty.messages.matches, []);
+    assert.equal(empty.facts.state === "available" ? empty.facts.matches.length : -1, 0);
+    for (const id of ["first", "second", "third"])
+      yield* knowledge.mutate(createFact(projectId, id), { kind: "user" });
+    yield* knowledge.mutate(
+      {
+        ...createFact(projectId, "unrelated"),
+        content: "Use readable garden labels.",
+        entities: [],
+        tags: [],
+      },
+      { kind: "user" },
+    );
+    const result = yield* knowledge.search({
+      projectId,
+      requestId: CommandId.make("preview-compact"),
+      query: "cache keys tenant",
+      preview: true,
+      limit: 50,
+    });
+    assert.deepEqual(result.messages.matches, []);
+    assert.equal(result.facts.state, "available");
+    if (result.facts.state !== "available") return;
+    assert.equal(result.facts.matches.length, 2);
+    assert.equal(result.facts.nextCursor, null);
+    assert.isFalse(result.facts.matches.some((item) => item.fact.id === "unrelated"));
+    const sql = yield* SqlClient.SqlClient;
+    assert.equal(
+      (yield* sql`SELECT command_id FROM project_knowledge_commands WHERE search_json IS NOT NULL`)
+        .length,
+      0,
+    );
+  }).pipe(Effect.provide(knowledgeTestLayer(HolographicMemory.layer, true))),
+);
diff --git a/apps/server/src/project/knowledge/ProjectKnowledge.ts b/apps/server/src/project/knowledge/ProjectKnowledge.ts
index 0c5d94f58ca6c..358bbab6edc57 100644
--- a/apps/server/src/project/knowledge/ProjectKnowledge.ts
+++ b/apps/server/src/project/knowledge/ProjectKnowledge.ts
@@ -1,5 +1,9 @@
 import {
   ActiveProjectFact,
+  boundProjectMemorySuggestionQuery,
+  isSubstantiveProjectMemoryQuery,
+  selectProjectMemorySuggestions,
+  type ProjectMemorySuggestion,
   type AssistedLearningRun,
   type KnowledgeConflictHint,
   type KnowledgeFactSource,
@@ -95,6 +99,9 @@ export class ProjectKnowledge extends Context.Service<
     readonly search: (
       input: ProjectKnowledgeSearchInput,
     ) => Effect.Effect<ProjectKnowledgeSearchResult, ProjectKnowledgeError>;
+    readonly suggest: (
+      input: Pick<ProjectKnowledgeSearchInput, "projectId" | "query" | "requestId">,
+    ) => Effect.Effect<ReadonlyArray<ProjectMemorySuggestion>, ProjectKnowledgeError>;
     readonly prepareContext: (
       input: ProjectKnowledgeContext,
     ) => Effect.Effect<ProjectKnowledgePreparedContext, ProjectKnowledgeError>;
@@ -124,7 +131,7 @@ export class ProjectKnowledge extends Context.Service<
     }) => Effect.Effect<string | null, ProjectKnowledgeError>;
     /**
      * Saves an automatically learned fact through the normal create path. An exact duplicate
-     * creates nothing; lexical similarities never block saving or replace an existing fact.
+     * adds only new validated citations; lexical similarities never replace an existing fact.
      */
     readonly saveAutomatic: (
       input: Extract<ProjectKnowledgeMutation, { readonly action: "create" }>,
@@ -289,6 +296,7 @@ const make = Effect.gen(function* () {
             threadId: input.threadId,
             messageId: source.messageId,
             digest: contentDigest,
+            ...(message.runId === null ? {} : { runId: message.runId }),
           },
           text: message.text,
           title: projection.thread.title,
@@ -312,7 +320,11 @@ const make = Effect.gen(function* () {
     for (const source of fact.sources) {
       if (source.kind === "user") continue;
       const result = yield* readSource({ projectId: fact.projectId, ...source, includeArchived });
-      if (result.state !== "available") return false;
+      if (
+        result.state !== "available" ||
+        (source.runId !== undefined && result.source.runId !== source.runId)
+      )
+        return false;
     }
     return true;
   });
@@ -347,11 +359,12 @@ const make = Effect.gen(function* () {
       WHERE ${sql.in("thread_id", [...new Set(refs.map((ref) => ref.source.threadId))])}`;
     const messageRows = yield* sql<{
       readonly messageId: string;
+      readonly runId: string | null;
       readonly threadId: string;
       readonly role: string;
       readonly streaming: number;
       readonly text: string | null;
-    }>`SELECT message_id AS "messageId", thread_id AS "threadId", role, streaming,
+    }>`SELECT message_id AS "messageId", run_id AS "runId", thread_id AS "threadId", role, streaming,
         json_extract(payload_json, '$.text') AS text
       FROM orchestration_v2_projection_messages
       WHERE ${sql.in("message_id", [...new Set(refs.map((ref) => ref.source.messageId))])}
@@ -378,7 +391,11 @@ const make = Effect.gen(function* () {
           contentDigest = yield* digest(message.text ?? "");
           digests.set(message.messageId, contentDigest);
         }
-        if (contentDigest !== source.digest) reason = "changed";
+        if (
+          contentDigest !== source.digest ||
+          (source.runId !== undefined && source.runId !== message.runId)
+        )
+          reason = "changed";
       }
       if (reason !== null) reasons.set(factId, reason);
     }
@@ -789,14 +806,40 @@ const make = Effect.gen(function* () {
     };
   });
   const search: ProjectKnowledge["Service"]["search"] = Effect.fn("ProjectKnowledge.search")(
-    function* (input) {
+    function* (request) {
+      const {
+        factCursor: _previewFactCursor,
+        cursor: _previewMessageCursor,
+        ...previewRequest
+      } = request;
+      const input =
+        request.preview === true
+          ? {
+              ...previewRequest,
+              query: boundProjectMemorySuggestionQuery(request.query),
+              limit: 8,
+            }
+          : request;
       yield* requireProject(input.projectId);
-      const messages = yield* threads
-        .search({
-          ...input,
-          ...(input.messageLimit === undefined ? {} : { limit: input.messageLimit }),
-        })
-        .pipe(Effect.mapError(storageError(input.projectId)));
+      if (input.preview === true && !isSubstantiveProjectMemoryQuery(input.query))
+        return {
+          messages: { matches: [] },
+          facts: {
+            state: "available" as const,
+            matches: [],
+            coverage: "complete" as const,
+            nextCursor: null,
+          },
+        };
+      const messages =
+        input.preview === true
+          ? { matches: [] }
+          : yield* threads
+              .search({
+                ...input,
+                ...(input.messageLimit === undefined ? {} : { limit: input.messageLimit }),
+              })
+              .pipe(Effect.mapError(storageError(input.projectId)));
       const entities = [
         ...new Set((input.entities ?? []).map((entity) => entity.toLowerCase())),
       ].sort();
@@ -1008,6 +1051,27 @@ const make = Effect.gen(function* () {
       const early = yield* resolveMatches(prior?.search ?? null).pipe(
         Effect.mapError(storageError(input.projectId)),
       );
+      if (input.preview === true)
+        return {
+          messages,
+          facts: {
+            state: "available" as const,
+            matches: selectProjectMemorySuggestions(
+              {
+                messages: { matches: [] },
+                facts: {
+                  state: "available",
+                  matches: early.resolved.map(({ fact, score }) => ({ fact, score })),
+                  coverage: early.ranked.coverage,
+                  nextCursor: null,
+                },
+              },
+              input.query,
+            ).map(({ fact, score }) => ({ fact, score })),
+            coverage: early.ranked.coverage,
+            nextCursor: null,
+          },
+        };
       return yield* sql
         .withTransaction(
           Effect.gen(function* () {
@@ -1096,6 +1160,22 @@ const make = Effect.gen(function* () {
     );
     yield* store.recordDelivery(checked).pipe(Effect.mapError(storageError(delivery.projectId)));
   });
+  const suggest: ProjectKnowledge["Service"]["suggest"] = Effect.fn("ProjectKnowledge.suggest")(
+    function* (input) {
+      if (!isSubstantiveProjectMemoryQuery(input.query)) return [];
+      const result = yield* search({
+        ...input,
+        query: boundProjectMemorySuggestionQuery(input.query),
+        recordRetrieval: false,
+        preview: true,
+        minTrust: 0.5,
+        limit: 8,
+        messageLimit: 1,
+      });
+      return selectProjectMemorySuggestions(result, input.query);
+    },
+  );
+
   // A fact edit is not a source edit: check the citations of the revision actually sent.
   // Scrubbing is monotone, so restoring a thread cannot restore retained excerpts.
   const revalidateDelivery = Effect.fn("ProjectKnowledge.revalidateDelivery")(function* (
@@ -1305,8 +1385,67 @@ const make = Effect.gen(function* () {
         Effect.gen(function* () {
           if ((yield* store.find(input.projectId, input.factId)) !== null)
             return { outcome: "existing" as const };
-          if (yield* store.hasDuplicateContent(input.projectId, input.content))
+          const duplicate = yield* store.findDuplicateContent(input.projectId, input.content);
+          if (
+            duplicate !== null &&
+            duplicate.status === "saved" &&
+            duplicate.supersededBy == null
+          ) {
+            if (
+              input.sources.length === 0 ||
+              input.sources.some((source) => source.kind === "user") ||
+              !(yield* sourcesAvailable(input, true))
+            )
+              return yield* new ProjectKnowledgeError({
+                reason: "invalid_source",
+                projectId: input.projectId,
+                factId: input.factId,
+              });
+            const sourceKey = (source: KnowledgeFactSource) =>
+              source.kind === "user"
+                ? "user"
+                : JSON.stringify([source.threadId, source.messageId, source.digest]);
+            const known = new Set(duplicate.sources.map(sourceKey));
+            const sources = [...duplicate.sources];
+            for (const source of input.sources) {
+              const key = sourceKey(source);
+              if (!known.has(key) && sources.length < 16) {
+                sources.push(source);
+                known.add(key);
+              }
+            }
+            if (sources.length > duplicate.sources.length) {
+              const now = DateTime.formatIso(yield* DateTime.now);
+              const fact = {
+                ...duplicate,
+                sources,
+                revision: duplicate.revision + 1,
+                updatedAt: now,
+              };
+              if (!(yield* store.update(fact, duplicate.revision)))
+                return yield* new ProjectKnowledgeError({
+                  reason: "conflict",
+                  projectId: input.projectId,
+                  factId: duplicate.id,
+                });
+              yield* store.recordHistory({
+                projectId: input.projectId,
+                factId: fact.id,
+                revision: fact.revision,
+                event: "edited",
+                actor,
+                at: now,
+                contentDigest: yield* digest(fact.content ?? ""),
+                content: fact.content,
+                sources,
+                trustBefore: null,
+                trustAfter: fact.trust,
+                helpful: null,
+                relatedFactId: null,
+              });
+            }
             return { outcome: "duplicate" as const };
+          }
           yield* mutate(input, actor);
           return { outcome: "saved" as const };
         }),
@@ -1425,6 +1564,7 @@ const make = Effect.gen(function* () {
     readSource,
     readSources,
     search,
+    suggest,
     prepareContext,
     resolveForTurn,
     recordDelivery,
diff --git a/apps/server/src/project/knowledge/assistedLearningSchedule.ts b/apps/server/src/project/knowledge/assistedLearningSchedule.ts
index a23cbeb3478f1..ef09f326811d6 100644
--- a/apps/server/src/project/knowledge/assistedLearningSchedule.ts
+++ b/apps/server/src/project/knowledge/assistedLearningSchedule.ts
@@ -45,6 +45,8 @@ export class AssistedLearningError extends Schema.TaggedError<AssistedLearningEr
 ) {}
 
 export interface AssistedLearningRunnerShape {
+  readonly drainDue: Effect.Effect<void, AssistedLearningError>;
+  readonly enqueueRun: AssistedLearningRunnerShape["extractRun"];
   readonly extractRun: (input: {
     readonly threadId: ThreadId;
     readonly runId: RunId;
@@ -55,6 +57,10 @@ export interface AssistedLearningRunnerShape {
 export class AssistedLearningRunner extends Context.Reference<AssistedLearningRunnerShape>(
   "t3/project/knowledge/AssistedLearningRunner",
   {
-    defaultValue: () => ({ extractRun: () => Effect.void }),
+    defaultValue: () => ({
+      extractRun: () => Effect.void,
+      enqueueRun: () => Effect.void,
+      drainDue: Effect.void,
+    }),
   },
 ) {}
diff --git a/apps/server/src/project/knowledge/holographicScoring.ts b/apps/server/src/project/knowledge/holographicScoring.ts
index 63c38b835f9dd..bf819c8fcfe3a 100644
--- a/apps/server/src/project/knowledge/holographicScoring.ts
+++ b/apps/server/src/project/knowledge/holographicScoring.ts
@@ -2,7 +2,7 @@
 export function projectMemorySearchTokens(text: string): string[] {
   return [
     ...new Set(
-      (text.match(/[a-zA-Z0-9_/:.]+/g) ?? [])
+      (text.match(/[\p{L}\p{N}_/:.]+/gu) ?? [])
         .filter((token) => token.length >= 2)
         .map((token) => token.toLowerCase()),
     ),
diff --git a/apps/server/src/project/knowledge/persistence.ts b/apps/server/src/project/knowledge/persistence.ts
index f36f5d59345d3..c8efbd66bc30e 100644
--- a/apps/server/src/project/knowledge/persistence.ts
+++ b/apps/server/src/project/knowledge/persistence.ts
@@ -305,7 +305,7 @@ export const makeStore = Effect.gen(function* () {
       partial: ids.length > 1000,
     };
   });
-  const hasDuplicateContent = Effect.fn("ProjectKnowledgeStore.hasDuplicateContent")(function* (
+  const findDuplicateContent = Effect.fn("ProjectKnowledgeStore.findDuplicateContent")(function* (
     projectId: ProjectId,
     content: string,
   ) {
@@ -320,8 +320,9 @@ export const makeStore = Effect.gen(function* () {
         WHERE project_id = ${projectId} AND status = 'saved' AND superseded_by_id IS NULL
           AND content IS NOT NULL AND id > ${afterId ?? ""}
         ORDER BY id ASC LIMIT 100`;
-      if (rows.some((row) => normalizeFactContent(row.content) === normalized)) return true;
-      if (rows.length < 100) return false;
+      const duplicate = rows.find((row) => normalizeFactContent(row.content) === normalized);
+      if (duplicate) return yield* find(projectId, duplicate.id);
+      if (rows.length < 100) return null;
       afterId = rows.at(-1)!.id;
     }
   });
@@ -726,7 +727,7 @@ export const makeStore = Effect.gen(function* () {
     recordSearch,
     candidates,
     similar,
-    hasDuplicateContent,
+    findDuplicateContent,
     recordHistory,
     eraseHistory,
     history,
diff --git a/apps/server/src/provider/agentContextBudget.json b/apps/server/src/provider/agentContextBudget.json
index 5fd7388d3c0aa..14e3561258e78 100644
--- a/apps/server/src/provider/agentContextBudget.json
+++ b/apps/server/src/provider/agentContextBudget.json
@@ -1,5 +1,5 @@
 {
   "claudeSystemAppendBytes": 8824,
   "codexAdditionalContextBytes": 10550,
-  "mcpToolListJsonBytes": 66687
+  "mcpToolListJsonBytes": 66669
 }
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index c58e7e380fef9..78ac97fd5dfdc 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -599,7 +599,7 @@ const layerOrchestrationV2Runtime = RuntimeLayer.layerProduction.pipe(
     ),
   ),
   Layer.provide(
-    AssistedLearning.layerRunner.pipe(
+    AssistedLearning.layerWorker.pipe(
       Layer.provide(Layer.mergeAll(ProjectionStoreV2.layer, TextGeneration.layer)),
     ),
   ),
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index 016571d10dbb0..ae8dfa132c151 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -3981,6 +3981,7 @@ export default function ChatView(props: ChatViewProps) {
                 />
 
                 <ProjectMemoryDialogHost
+                  suggest={serverThread === null || serverThread.latestUserMessageAt === null}
                   environmentId={activeThread.environmentId}
                   projectId={activeThread.projectId}
                   composerDraftTarget={composerDraftTarget}
diff --git a/apps/web/src/components/projectKnowledge/AssistedLearningSection.tsx b/apps/web/src/components/projectKnowledge/AssistedLearningSection.tsx
index c224e730de43a..41b32f024a3e8 100644
--- a/apps/web/src/components/projectKnowledge/AssistedLearningSection.tsx
+++ b/apps/web/src/components/projectKnowledge/AssistedLearningSection.tsx
@@ -59,8 +59,8 @@ export function AssistedLearningSection(props: {
         />
       </div>
       <p className="text-xs text-muted-foreground">
-        After each run in this project, your text generation model reads that run and saves up to
-        three cited facts. Each run costs one model call.
+        Completed runs are grouped into background learning batches. Your text generation model
+        saves up to three cited facts per batch; eligible batches use at most one model call.
       </p>
       {lastRun ? <p className="text-xs">{assistedLearningRunLabel(lastRun)}</p> : null}
       {!canWrite ? (
diff --git a/apps/web/src/components/projectKnowledge/ProjectMemoryPanel.browser.test.tsx b/apps/web/src/components/projectKnowledge/ProjectMemoryPanel.browser.test.tsx
index 27beaaf859d62..3aee7444caa69 100644
--- a/apps/web/src/components/projectKnowledge/ProjectMemoryPanel.browser.test.tsx
+++ b/apps/web/src/components/projectKnowledge/ProjectMemoryPanel.browser.test.tsx
@@ -22,7 +22,7 @@ import { projectKnowledgeContextRecord } from "@t3tools/client-runtime/projectKn
 import { Atom, AtomRegistry, AsyncResult } from "effect/reactivity";
 import { expect, it, vi } from "vite-plus/test";
 import { page, userEvent } from "vite-plus/test/browser";
-import { act, render, type Screen } from "../../../test/render";
+import { act, fakeTimers, render, type Screen } from "../../../test/render";
 
 const state = vi.hoisted(() => ({
   config: null as unknown,
@@ -76,7 +76,7 @@ vi.mock(
           state.readSource(input);
           return state.source;
         },
-        prepareContext: { label: "prepare" },
+        prepareContext: { label: "prepare", permissionAtom: () => state.permission },
         mutate: { label: "mutate", permissionAtom: () => state.permission },
       },
     }) as never,
@@ -165,7 +165,13 @@ async function setup(viewport: "desktop" | "narrow" = "desktop") {
   await page.viewport(viewport === "desktop" ? 1280 : 390, 900);
   const registry = AtomRegistry.make();
   state.config = Atom.make({
-    environment: { capabilities: { projectKnowledge: true, projectKnowledgeHistory: true } },
+    environment: {
+      capabilities: {
+        projectKnowledge: true,
+        projectKnowledgePreview: true,
+        projectKnowledgeHistory: true,
+      },
+    },
   });
   state.permission = Atom.make(true);
   state.list = Atom.make(AsyncResult.success({ facts: [fact], nextCursor: null }));
@@ -1229,3 +1235,65 @@ it("shows automatic facts as saved, with citations and the project switch", asyn
     },
   });
 });
+
+it("suggests cited memory for a completed first draft and keeps dismissal independent of attachment", async () => {
+  const registry = await setup();
+  await using _screen = await render(
+    <RegistryContext.Provider value={registry}>
+      <div className="mx-auto w-[640px] p-6">
+        <p>New request</p>
+        <ProjectMemoryDialogHost {...scope} suggest composerDraftTarget={target} />
+      </div>
+    </RegistryContext.Provider>,
+  );
+  using _timers = fakeTimers();
+  {
+    expect(state.searchRequest).not.toHaveBeenCalled();
+    await act(() =>
+      useComposerDraftStore
+        .getState()
+        .setPrompt(target, "Change cache keys to include tenant IDs."),
+    );
+    await act(async () => vi.advanceTimersByTimeAsync(1000));
+    await expect
+      .element(page.getByText(/Project memory: Cache keys include tenant IDs/))
+      .toBeVisible();
+    expect(state.searchRequest.mock.calls[0]?.[0].input).toMatchObject({
+      preview: true,
+      recordRetrieval: false,
+      query: "Change cache keys to include tenant IDs.",
+    });
+    await act(() =>
+      useComposerDraftStore
+        .getState()
+        .setPrompt(
+          target,
+          "Change cache keys to include tenant IDs. Keep the existing conventions.",
+        ),
+    );
+    await expect
+      .element(page.getByText(/Project memory: Cache keys include tenant IDs/))
+      .toBeVisible();
+    await act(() =>
+      useComposerDraftStore
+        .getState()
+        .setPrompt(target, "Replace the sign in page with a new layout."),
+    );
+    await expect
+      .element(page.getByText(/Project memory: Cache keys include tenant IDs/))
+      .not.toBeInTheDocument();
+    await act(() =>
+      useComposerDraftStore
+        .getState()
+        .setPrompt(target, "Change cache keys to include tenant IDs."),
+    );
+    await expect
+      .element(page.getByText(/Project memory: Cache keys include tenant IDs/))
+      .toBeVisible();
+    await page.getByRole("button", { name: "Dismiss", exact: true }).click();
+    await expect
+      .element(page.getByText(/Project memory: Cache keys include tenant IDs/))
+      .not.toBeInTheDocument();
+    expect(state.prepare).not.toHaveBeenCalled();
+  }
+});
diff --git a/apps/web/src/components/projectKnowledge/ProjectMemoryPanel.tsx b/apps/web/src/components/projectKnowledge/ProjectMemoryPanel.tsx
index 7b8512b4414cf..2efb06b91cdf8 100644
--- a/apps/web/src/components/projectKnowledge/ProjectMemoryPanel.tsx
+++ b/apps/web/src/components/projectKnowledge/ProjectMemoryPanel.tsx
@@ -19,7 +19,10 @@ import {
   type ProjectKnowledgeSearchInput,
   type ThreadId,
 } from "@t3tools/contracts";
-import { projectKnowledgeContextRecord } from "@t3tools/client-runtime/projectKnowledge";
+import {
+  addProjectMemorySuggestion,
+  projectKnowledgeContextRecord,
+} from "@t3tools/client-runtime/projectKnowledge";
 import { scopedThreadKey } from "@t3tools/client-runtime/environment";
 import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
 import { BrainIcon } from "lucide-react";
@@ -49,6 +52,7 @@ import {
 import { ConflictHintRow, KnowledgeHealthStrip } from "./ProjectFactDetail";
 import { AssistedLearningSection } from "./AssistedLearningSection";
 import { ProjectFactEditor, type EditableFact, type FactEditorSeed } from "./ProjectFactEditor";
+import { ProjectMemorySuggestions } from "./ProjectMemorySuggestions";
 import { ProjectMemoryFactList } from "./ProjectMemoryFactList";
 import {
   FactInspector,
@@ -64,6 +68,7 @@ type Scope = {
   environmentId: EnvironmentId;
   projectId: ProjectId;
   composerDraftTarget: ComposerThreadTarget;
+  suggest?: boolean;
 };
 type ProjectScope = Pick<Scope, "environmentId" | "projectId">;
 type MessageCitation = { readonly threadId: ThreadId; readonly messageId: MessageId };
@@ -76,6 +81,7 @@ type OpenRequest = ProjectScope & {
   readonly message: MessageCitation | null;
   readonly fact: FactFocus | null;
   readonly key: number;
+  readonly selection?: KnowledgeSelection;
 };
 const openRequestAtom = Atom.make<OpenRequest | null>(null).pipe(
   Atom.keepAlive,
@@ -136,6 +142,7 @@ export function ProjectMemoryPanel(props: ProjectScope) {
 
 export function ProjectMemoryDialogHost(props: Scope) {
   const available = useProjectMemoryAvailable(props.environmentId);
+  const config = useAtomValue(serverEnvironment.configValueAtom(props.environmentId));
   const [request, setRequest] = useAtom(openRequestAtom);
   // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- releases the shared open request this host holds until unmount
   useEffect(() => () => setRequest(null), [setRequest]);
@@ -147,29 +154,59 @@ export function ProjectMemoryDialogHost(props: Scope) {
       ? request
       : null;
   return (
-    <Dialog
-      open={active !== null}
-      onOpenChange={(open) => {
-        if (!open) setRequest(null);
-      }}
-    >
-      <DialogPopup className="h-[min(48rem,calc(100dvh-2rem))] max-w-5xl max-sm:h-[calc(100dvh-3rem)]">
-        <DialogHeader>
-          <DialogTitle>Project memory</DialogTitle>
-          <DialogDescription>
-            Browse saved project facts and their evidence, and choose what belongs in this draft.
-          </DialogDescription>
-        </DialogHeader>
-        {active ? (
-          <MemoryContents
-            key={`${active.key}:${typeof props.composerDraftTarget === "string" ? props.composerDraftTarget : scopedThreadKey(props.composerDraftTarget)}`}
-            {...props}
-            seedMessage={active.message}
-            focusFact={active.fact}
-          />
-        ) : null}
-      </DialogPopup>
-    </Dialog>
+    <>
+      {available &&
+      config?.environment.capabilities.projectKnowledgePreview === true &&
+      props.suggest ? (
+        <ProjectMemorySuggestions
+          key={`${props.environmentId}:${props.projectId}:${typeof props.composerDraftTarget === "string" ? props.composerDraftTarget : scopedThreadKey(props.composerDraftTarget)}`}
+          {...props}
+          onUse={(fact, query) =>
+            setRequest({
+              environmentId: props.environmentId,
+              projectId: props.projectId,
+              message: null,
+              fact: { id: fact.id, query },
+              selection: { kind: "fact", factId: fact.id, revision: fact.revision },
+              key: takeRequestKey(),
+            })
+          }
+          onSource={(source) =>
+            setRequest({
+              environmentId: props.environmentId,
+              projectId: props.projectId,
+              message: source,
+              fact: null,
+              key: takeRequestKey(),
+            })
+          }
+        />
+      ) : null}
+      <Dialog
+        open={active !== null}
+        onOpenChange={(open) => {
+          if (!open) setRequest(null);
+        }}
+      >
+        <DialogPopup className="h-[min(48rem,calc(100dvh-2rem))] max-w-5xl max-sm:h-[calc(100dvh-3rem)]">
+          <DialogHeader>
+            <DialogTitle>Project memory</DialogTitle>
+            <DialogDescription>
+              Browse saved project facts and their evidence, and choose what belongs in this draft.
+            </DialogDescription>
+          </DialogHeader>
+          {active ? (
+            <MemoryContents
+              key={`${active.key}:${typeof props.composerDraftTarget === "string" ? props.composerDraftTarget : scopedThreadKey(props.composerDraftTarget)}`}
+              {...props}
+              seedMessage={active.message}
+              focusFact={active.fact}
+              suggestedSelection={active.selection}
+            />
+          ) : null}
+        </DialogPopup>
+      </Dialog>
+    </>
   );
 }
 
@@ -190,14 +227,25 @@ function MemoryContents(
   props: Scope & {
     readonly seedMessage: MessageCitation | null;
     readonly focusFact: FactFocus | null;
+    readonly suggestedSelection?: KnowledgeSelection | undefined;
   },
 ) {
   const target = props.composerDraftTarget;
   const registry = useContext(RegistryContext);
   const draft = useComposerThreadDraft(target);
-  const attached = draft.knowledgeContexts?.[0];
+  const candidate = draft.knowledgeContexts?.[0];
+  const attached =
+    candidate?.knowledge.environmentId === props.environmentId &&
+    candidate.knowledge.projectId === props.projectId
+      ? candidate
+      : undefined;
   const [selections, setSelections] = useState<ReadonlyArray<KnowledgeSelection>>(
-    attached?.knowledge.selections ?? [],
+    props.suggestedSelection?.kind === "fact"
+      ? addProjectMemorySuggestion(attached?.knowledge.selections ?? [], {
+          id: props.suggestedSelection.factId,
+          revision: props.suggestedSelection.revision,
+        })
+      : (attached?.knowledge.selections ?? []),
   );
   const [query, setQuery] = useState(props.focusFact?.query ?? "");
   const [searchInput, setSearchInput] = useState<ProjectKnowledgeSearchInput | null>(() =>
diff --git a/apps/web/src/components/projectKnowledge/ProjectMemorySuggestions.tsx b/apps/web/src/components/projectKnowledge/ProjectMemorySuggestions.tsx
new file mode 100644
index 0000000000000..7209263426614
--- /dev/null
+++ b/apps/web/src/components/projectKnowledge/ProjectMemorySuggestions.tsx
@@ -0,0 +1,109 @@
+import { useAtomValue } from "@effect/atom-react";
+import { useEffect, useState } from "react";
+import {
+  CommandId,
+  type EnvironmentId,
+  type ProjectId,
+  type ProjectFact,
+  type KnowledgeMessageRef,
+} from "@t3tools/contracts";
+import {
+  boundProjectMemorySuggestionQuery,
+  isSubstantiveProjectMemoryQuery,
+  selectProjectMemorySuggestions,
+} from "@t3tools/client-runtime/projectKnowledge";
+import { useComposerThreadDraft, type ComposerThreadTarget } from "../../composerDraftStore";
+import { useEnvironmentQuery } from "../../state/query";
+import { projectKnowledge } from "../../state/projectKnowledge";
+import { randomUUID } from "../../lib/utils";
+import { Button } from "../ui/button";
+
+export function ProjectMemorySuggestions(props: {
+  environmentId: EnvironmentId;
+  projectId: ProjectId;
+  composerDraftTarget: ComposerThreadTarget;
+  onUse: (fact: ProjectFact, query: string) => void;
+  onSource: (source: KnowledgeMessageRef) => void;
+}) {
+  const canUse = useAtomValue(projectKnowledge.prepareContext.permissionAtom(props.environmentId));
+  const draft = useComposerThreadDraft(props.composerDraftTarget);
+  const [request, setRequest] = useState<{ query: string; requestId: CommandId } | null>(null);
+  const [dismissed, setDismissed] = useState<ReadonlyArray<string>>([]);
+  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- issues one recall request after the user pauses composing a substantive draft
+  useEffect(() => {
+    if (request || !isSubstantiveProjectMemoryQuery(draft.prompt)) return;
+    const timer = setTimeout(
+      () =>
+        setRequest({
+          query: boundProjectMemorySuggestionQuery(draft.prompt),
+          requestId: CommandId.make(randomUUID()),
+        }),
+      1000,
+    );
+    return () => clearTimeout(timer);
+  }, [draft.prompt, request]);
+  const result = useEnvironmentQuery(
+    request
+      ? projectKnowledge.search({
+          environmentId: props.environmentId,
+          input: {
+            ...request,
+            projectId: props.projectId,
+            recordRetrieval: false,
+            preview: true,
+            minTrust: 0.5,
+            limit: 8,
+            messageLimit: 1,
+          },
+        })
+      : null,
+  );
+  const suggestions = result.data
+    ? selectProjectMemorySuggestions(result.data, request?.query).filter(
+        ({ fact }) => !dismissed.includes(fact.id),
+      )
+    : [];
+  if (!request || !draft.prompt.trimStart().startsWith(request.query) || !suggestions.length)
+    return null;
+  return (
+    <div className="flex flex-col gap-1" aria-label="Related project memory">
+      {suggestions.map(({ fact, reason }) => (
+        <div key={fact.id} className="flex items-center gap-2 text-xs">
+          <span className="min-w-0 flex-1 truncate">
+            Project memory: {fact.content}
+            <span className="block text-muted-foreground">{reason}</span>
+          </span>
+          {fact.sources.some((source) => source.kind === "user") ? <span>Saved by you</span> : null}
+          {fact.sources
+            .filter((source) => source.kind === "message")
+            .slice(0, 1)
+            .flatMap((source) =>
+              source.kind === "message"
+                ? [
+                    <Button
+                      key={source.messageId}
+                      variant="ghost"
+                      size="sm"
+                      onClick={() => props.onSource(source)}
+                    >
+                      Source
+                    </Button>,
+                  ]
+                : [],
+            )}
+          <Button
+            variant="ghost"
+            size="sm"
+            disabled={!canUse}
+            onClick={() => props.onUse(fact, request!.query)}
+          >
+            Use
+          </Button>
+          <Button variant="ghost" size="sm" onClick={() => setDismissed([...dismissed, fact.id])}>
+            Dismiss
+          </Button>
+        </div>
+      ))}
+    </div>
+  );
+}
diff --git a/apps/web/src/components/settings/ZackSettings.tsx b/apps/web/src/components/settings/ZackSettings.tsx
index 29ef7440f8cf7..3fa6609a22ab4 100644
--- a/apps/web/src/components/settings/ZackSettings.tsx
+++ b/apps/web/src/components/settings/ZackSettings.tsx
@@ -71,8 +71,8 @@ function AssistedLearningRow() {
       description={
         unavailableReason ??
         (isProjectScope
-          ? "After each run in this project, your text generation model saves up to three cited facts to Project memory. Each run costs one model call."
-          : "After each run, your text generation model saves up to three cited facts to Project memory. Each run costs one model call. Projects can override it.")
+          ? "Completed runs in this project are grouped into background learning batches. Your text generation model saves up to three cited facts per batch; eligible batches use at most one model call."
+          : "Completed runs are grouped into background learning batches. Your text generation model saves up to three cited facts per batch; eligible batches use at most one model call. Projects can override it.")
       }
       resetAction={
         unavailableReason === null &&
diff --git a/docs/user/composer.md b/docs/user/composer.md
index 8115114548855..e84b0ee4752cf 100644
--- a/docs/user/composer.md
+++ b/docs/user/composer.md
@@ -130,7 +130,7 @@ Open **Project memory** from the thread details, the command palette, or
 `mod+shift+u` on web or desktop, or from thread actions on mobile. Search
 conversations and saved facts in the current project, inspect their sources, and
 select evidence for your next message. Selecting a fact shows its evidence;
-only its checkbox adds it to your draft. Archived conversations are excluded unless
+choose **Attach** to include the selected evidence in your draft. Archived conversations are excluded unless
 you include them. A fact whose cited message was edited, deleted, or archived is
 flagged in the list.
 
@@ -154,24 +154,29 @@ up in recall unless you show superseded facts. After you save, T3 points out
 existing facts that look like duplicates or possible contradictions so you can
 compare them; it never merges or replaces them on its own.
 
-T3 also saves facts from finished runs on its own. After a run finishes, fails, or
-is stopped, your text generation model reads that run's messages and saves up to
-three decisions, constraints, or conventions, each citing the messages it came
-from. Each run costs one model call. To turn this off, use **Save facts from
-finished runs** under **Memory health** in Project memory, or in **Settings → Labs →
-Zack** for one project or every project. The **Automatic** filter lists these facts,
-and a fact from a run that failed or was stopped says so.
-
-An exact duplicate of an existing fact is skipped. Different facts are saved
-separately, even when they look similar or may conflict. Both can come up in recall
-until you supersede one.
-Agents find saved facts by searching; nothing is added to their prompts on its own.
-A fact's trust rating, age, and how often it is recalled all affect its rank, and a
-fact rated below the recall threshold stops coming up. Facts are not deleted
-automatically.
-A fact you forget is not saved again from the same run, but a later run can learn it
-again. Project memory shows what the last run did, including why it was skipped or
-failed.
+When **Save facts from finished runs** is on, T3 reviews new runs from a thread
+and its child threads together. A batch is eligible after eight completed runs or
+30 minutes of inactivity. Your text generation model can propose up to three
+facts in one call per eligible batch. Each fact needs a citation to a message
+you wrote or corroborating messages from separate runs in different threads.
+Failed and stopped runs can supply evidence. Change this setting under **Memory
+health** in Project memory or in **Settings → Labs → Zack**. Project memory
+shows the last outcome and the **Automatic** filter lists automatically saved facts.
+
+An exact repeat can add new citations to a saved fact. You decide when similar
+or conflicting facts should supersede one another. Trust, age and retrieval
+history affect recall. Forgetting a fact removes its content, and a later run
+can supply new evidence for it.
+
+Pause while composing the first request in a thread to see up to two related
+facts. Each suggestion shows why it matched. Open its source, choose **Use** to
+review it for attachment, or **Dismiss** it for this draft. Previewing a
+suggestion costs no model tokens and does not increase its trust.
+
+Agents can search project memory on demand. On an unattended first turn with T3
+tools available and room in the context window, the agent can also receive up to
+two fact IDs. It can open a fact and follow its citations when the task needs
+the evidence.
 
 A fact's details show its history: when it was created, edited, superseded, and
 rated helpful or unhelpful, with the trust change from each rating. **Memory health** counts facts by status. When facts lose their cited
diff --git a/packages/client-runtime/src/projectKnowledge/index.test.ts b/packages/client-runtime/src/projectKnowledge/index.test.ts
index e02b32a6c9cd6..123ec31a18286 100644
--- a/packages/client-runtime/src/projectKnowledge/index.test.ts
+++ b/packages/client-runtime/src/projectKnowledge/index.test.ts
@@ -12,6 +12,7 @@ import {
 } from "@t3tools/contracts";
 import { expect, it } from "vite-plus/test";
 import {
+  addProjectMemorySuggestion,
   deliveredKnowledgeNotes,
   deliveredKnowledgeSnapshot,
   KNOWLEDGE_DELIVERY_OMISSION_LABEL,
@@ -134,3 +135,20 @@ it("traces trust from before the first recorded event through each feedback", ()
     "Marked unhelpful",
   ]);
 });
+
+it("adds suggested facts without losing selections or duplicating revisions", () => {
+  const first = { kind: "fact" as const, factId: ProjectFactId.make("first"), revision: 1 };
+  const second = { kind: "fact" as const, factId: ProjectFactId.make("second"), revision: 1 };
+  expect(addProjectMemorySuggestion([first], { id: second.factId, revision: 2 })).toEqual([
+    first,
+    { ...second, revision: 2 },
+  ]);
+  expect(
+    addProjectMemorySuggestion([first, second, first], { id: first.factId, revision: 3 }),
+  ).toEqual([{ ...first, revision: 3 }, second]);
+  const full = Array.from({ length: 20 }, (_, i) => ({
+    ...first,
+    factId: ProjectFactId.make(String(i)),
+  }));
+  expect(addProjectMemorySuggestion(full, { id: second.factId, revision: 1 })).toBe(full);
+});
diff --git a/packages/client-runtime/src/projectKnowledge/index.ts b/packages/client-runtime/src/projectKnowledge/index.ts
index 598ff3acb56ec..61c32b03d174b 100644
--- a/packages/client-runtime/src/projectKnowledge/index.ts
+++ b/packages/client-runtime/src/projectKnowledge/index.ts
@@ -1,8 +1,15 @@
+export {
+  boundProjectMemorySuggestionQuery,
+  isSubstantiveProjectMemoryQuery,
+  selectProjectMemorySuggestions,
+  type ProjectMemorySuggestion,
+} from "@t3tools/contracts";
 import {
   WS_METHODS,
   type AssistedLearningRun,
   type KnowledgeConflictHint,
   type KnowledgeOrigin,
+  type KnowledgeSelection,
   type KnowledgeSourceUnavailableReason,
   type ProjectFact,
   type ProjectFactHistoryEntry,
@@ -219,3 +226,19 @@ export function knowledgeConflictHintLabel(hint: KnowledgeConflictHint): string
       return "Possible conflict with";
   }
 }
+
+export function addProjectMemorySuggestion(
+  selections: ReadonlyArray<KnowledgeSelection>,
+  fact: Pick<ProjectFact, "id" | "revision">,
+): ReadonlyArray<KnowledgeSelection> {
+  const selection = { kind: "fact" as const, factId: fact.id, revision: fact.revision };
+  const exists = selections.some((item) => item.kind === "fact" && item.factId === fact.id);
+  if (!exists) return selections.length < 20 ? [...selections, selection] : selections;
+  let replaced = false;
+  return selections.flatMap((item) => {
+    if (item.kind !== "fact" || item.factId !== fact.id) return [item];
+    if (replaced) return [];
+    replaced = true;
+    return [selection];
+  });
+}
diff --git a/packages/contracts/src/environment.test.ts b/packages/contracts/src/environment.test.ts
index 1b318ff19cdf4..b7adddb530768 100644
--- a/packages/contracts/src/environment.test.ts
+++ b/packages/contracts/src/environment.test.ts
@@ -22,6 +22,13 @@ describe("ExecutionEnvironmentDescriptor", () => {
     expect(decodeDescriptor(oldServer).capabilities).not.toHaveProperty(
       "projectKnowledgeDeliveries",
     );
+    expect(decodeDescriptor(oldServer).capabilities.projectKnowledgePreview).toBeUndefined();
+    expect(
+      decodeDescriptor({
+        ...oldServer,
+        capabilities: { ...oldServer.capabilities, projectKnowledgePreview: true },
+      }).capabilities.projectKnowledgePreview,
+    ).toBe(true);
     for (const supported of [false, true]) {
       expect(
         decodeDescriptor({
diff --git a/packages/contracts/src/environment.ts b/packages/contracts/src/environment.ts
index b718ea2062f23..7cda3fd70509b 100644
--- a/packages/contracts/src/environment.ts
+++ b/packages/contracts/src/environment.ts
@@ -77,6 +77,7 @@ export type ServerSelfUpdateCapability = typeof ServerSelfUpdateCapability.Type;
 export const ExecutionEnvironmentCapabilities = Schema.Struct({
   modelEvaluations: Schema.optionalKey(Schema.Boolean),
   projectKnowledge: Schema.optionalKey(Schema.Boolean),
+  projectKnowledgePreview: Schema.optionalKey(Schema.Boolean),
   /** projectKnowledge.readFact, projectKnowledge.status and the supersede mutation. */
   projectKnowledgeHistory: Schema.optionalKey(Schema.Boolean),
   /** projectKnowledge.readDeliveries and the recorded copy delivered with sent messages. */
diff --git a/packages/contracts/src/projectKnowledge.test.ts b/packages/contracts/src/projectKnowledge.test.ts
index f124fd571695d..1e0d5affab88e 100644
--- a/packages/contracts/src/projectKnowledge.test.ts
+++ b/packages/contracts/src/projectKnowledge.test.ts
@@ -3,12 +3,15 @@ import * as Schema from "effect/Schema";
 
 import {
   ProjectKnowledgeDelivery,
+  ProjectKnowledgeSearchResult,
+  selectProjectMemorySuggestions,
   ProjectKnowledgeListInput,
   ProjectKnowledgeListResult,
   ProjectKnowledgeMutation,
   ProjectKnowledgeStatus,
 } from "./projectKnowledge.ts";
 
+const decodeSearchResult = Schema.decodeUnknownSync(ProjectKnowledgeSearchResult);
 const decodeDelivery = Schema.decodeUnknownSync(ProjectKnowledgeDelivery);
 
 const decodeList = Schema.decodeUnknownSync(ProjectKnowledgeListResult);
@@ -137,3 +140,46 @@ it.each(["over_budget", "source_unavailable", "stale_revision", "not_permitted",
     expect(decodeDelivery({ ...oldDelivery, omissions }).omissions).toEqual(omissions);
   },
 );
+
+describe("project memory suggestions", () => {
+  it("keeps only strong cited matches and bounds optional context", () => {
+    const score = {
+      holographic: 1,
+      lexical: 1,
+      tokenOverlap: 0.4,
+      temporalDecay: 1,
+      reinforcement: 1,
+      trust: 0.8,
+      combined: 1,
+    };
+    const result = decodeSearchResult({
+      messages: { matches: [] },
+      facts: {
+        state: "available",
+        coverage: "complete",
+        nextCursor: null,
+        matches: [
+          { fact: { ...fact({ kind: "user" }), id: "uncited" }, score },
+          {
+            fact: { ...fact({ kind: "user" }), id: "weak", sources: [{ kind: "user" }] },
+            score: { ...score, lexical: 0, tokenOverlap: 0.01 },
+          },
+          ...["first", "second", "third"].map((id) => ({
+            fact: { ...fact({ kind: "user" }), id, sources: [{ kind: "user" }] },
+            score,
+          })),
+        ],
+      },
+    });
+    expect(selectProjectMemorySuggestions(result).map((item) => item.fact.id)).toEqual([
+      "first",
+      "second",
+    ]);
+    expect(
+      selectProjectMemorySuggestions({
+        ...result,
+        facts: { state: "unavailable", reason: "kernel_unavailable" },
+      }),
+    ).toEqual([]);
+  });
+});
diff --git a/packages/contracts/src/projectKnowledge.ts b/packages/contracts/src/projectKnowledge.ts
index 3780a2b47d103..039a77a285100 100644
--- a/packages/contracts/src/projectKnowledge.ts
+++ b/packages/contracts/src/projectKnowledge.ts
@@ -24,6 +24,7 @@ export const ProjectFactId = TrimmedNonEmptyString.pipe(Schema.brand("ProjectFac
 export type ProjectFactId = typeof ProjectFactId.Type;
 export const KnowledgeDigest = Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/));
 export const KnowledgeMessageRef = Schema.Struct({
+  runId: Schema.optionalKey(RunId),
   kind: Schema.Literal("message"),
   threadId: ThreadId,
   messageId: MessageId,
@@ -464,6 +465,8 @@ export const ProjectKnowledgeSearchInput = Schema.Struct({
   // Retrieval reinforces ranking. Browsing surfaces (as-you-type, previews) pass false so only
   // deliberate lookups count; omitted means true.
   recordRetrieval: Schema.optionalKey(Schema.Boolean),
+  /** Passive suggestions do not record receipts, reinforce retrieval, or return continuations. */
+  preview: Schema.optionalKey(Schema.Boolean),
 });
 export type ProjectKnowledgeSearchInput = typeof ProjectKnowledgeSearchInput.Type;
 export const KnowledgeScore = Schema.Struct({
@@ -491,6 +494,89 @@ const ProjectKnowledgeSearchResultSchema = Schema.Struct({
   ]),
 });
 export type ProjectKnowledgeSearchResult = typeof ProjectKnowledgeSearchResultSchema.Type;
+export interface ProjectMemorySuggestion {
+  readonly fact: ProjectFact;
+  readonly score: typeof KnowledgeScore.Type;
+  readonly reason: string;
+}
+
+const PROJECT_MEMORY_SUGGESTION_QUERY_MAX_LENGTH = 1000;
+
+export function boundProjectMemorySuggestionQuery(query: string): string {
+  return query.trim().slice(0, PROJECT_MEMORY_SUGGESTION_QUERY_MAX_LENGTH);
+}
+
+const memoryQueryFiller = new Set([
+  "the",
+  "and",
+  "for",
+  "this",
+  "that",
+  "with",
+  "please",
+  "help",
+  "can",
+  "you",
+  "could",
+  "would",
+  "want",
+  "need",
+  "hello",
+  "there",
+  "thanks",
+]);
+const memoryQueryTerms = (query: string) => [
+  ...new Set(
+    (
+      boundProjectMemorySuggestionQuery(query)
+        .toLowerCase()
+        .match(/[\p{L}\p{N}_/:.]+/gu) ?? []
+    ).filter((term) => term.length >= 3 && !memoryQueryFiller.has(term)),
+  ),
+];
+
+export function isSubstantiveProjectMemoryQuery(query: string): boolean {
+  const terms = memoryQueryTerms(query);
+  return (
+    terms.length >= 3 ||
+    terms.some(
+      (term) =>
+        /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u.test(term) && term.length >= 6,
+    )
+  );
+}
+
+export function selectProjectMemorySuggestions(
+  result: ProjectKnowledgeSearchResult,
+  query = "",
+): ReadonlyArray<ProjectMemorySuggestion> {
+  if (result.facts.state !== "available") return [];
+  const terms = memoryQueryTerms(query);
+  return result.facts.matches
+    .filter(
+      ({ fact, score }) =>
+        fact.status === "saved" &&
+        fact.supersededBy == null &&
+        fact.sources.length > 0 &&
+        score.trust >= 0.5 &&
+        score.combined > 0 &&
+        (score.tokenOverlap >= 0.15 || (score.lexical >= 0.65 && score.tokenOverlap >= 0.05)),
+    )
+    .slice(0, 2)
+    .map(({ fact, score }) => {
+      const content = [fact.content ?? "", ...fact.entities, ...fact.tags].join(" ").toLowerCase();
+      const matched = terms.filter((term) => content.includes(term)).slice(0, 3);
+      return {
+        fact,
+        score,
+        reason:
+          matched.length > 0
+            ? `Matches ${matched.map((term) => `“${term}”`).join(", ")} in saved project knowledge.`
+            : "Strong lexical match in saved project knowledge.",
+      };
+    });
+}
+
 export const ProjectKnowledgeSearchResult: Schema.Codec<
   ProjectKnowledgeSearchResult,
   typeof ProjectKnowledgeSearchResultSchema.Encoded
diff --git a/packages/provider-core/src/server/textGeneration.ts b/packages/provider-core/src/server/textGeneration.ts
index 499f8ca1d394d..2b831c209b7b2 100644
--- a/packages/provider-core/src/server/textGeneration.ts
+++ b/packages/provider-core/src/server/textGeneration.ts
@@ -103,9 +103,12 @@ export type ReviewGuideGenerationResult = Omit<
 export interface KnowledgeCandidatesGenerationInput {
   cwd: string;
   runOutcome: "completed" | "failed" | "interrupted";
-  /** Finalized messages of one run, oldest first; `ref` is what citations name. */
+  /** Finalized new evidence from one thread family, oldest first; `ref` is what citations name. */
   messages: ReadonlyArray<{
     readonly ref: string;
+    readonly threadId?: string;
+    readonly runId?: string;
+    readonly runOutcome?: "completed" | "failed" | "interrupted";
     readonly role: "user" | "assistant";
     readonly text: string;
   }>;
diff --git a/packages/provider-core/src/server/textGenerationPrompts.test.ts b/packages/provider-core/src/server/textGenerationPrompts.test.ts
index dabd14a23dd98..f16cda60ae0cf 100644
--- a/packages/provider-core/src/server/textGenerationPrompts.test.ts
+++ b/packages/provider-core/src/server/textGenerationPrompts.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vite-plus/test";
 
+import { buildKnowledgeCandidatesPrompt } from "./textGenerationPrompts.ts";
 import { normalizeCliError } from "./textGenerationUtils.ts";
 
 describe("normalizeCliError", () => {
@@ -15,3 +16,29 @@ describe("normalizeCliError", () => {
     expect(result.message).not.toContain("secret-token");
   });
 });
+
+it("preserves each run boundary and terminal outcome in family review prompts", () => {
+  const { prompt } = buildKnowledgeCandidatesPrompt({
+    runOutcome: "completed",
+    messages: [
+      {
+        ref: "M1",
+        role: "user",
+        text: "Keep the API stable.",
+        threadId: "root",
+        runId: "run-a",
+        runOutcome: "interrupted",
+      },
+      {
+        ref: "M2",
+        role: "assistant",
+        text: "Checked compatibility.",
+        threadId: "child",
+        runId: "run-b",
+        runOutcome: "completed",
+      },
+    ],
+  });
+  expect(prompt).toContain("[M1] user (T1/R1, interrupted):\nKeep the API stable.");
+  expect(prompt).toContain("[M2] assistant (T2/R2, completed):\nChecked compatibility.");
+});
diff --git a/packages/provider-core/src/server/textGenerationPrompts.ts b/packages/provider-core/src/server/textGenerationPrompts.ts
index 97e3b2ddb31f9..887867f034a2f 100644
--- a/packages/provider-core/src/server/textGenerationPrompts.ts
+++ b/packages/provider-core/src/server/textGenerationPrompts.ts
@@ -491,14 +491,25 @@ export interface KnowledgeCandidatesPromptInput {
   runOutcome: "completed" | "failed" | "interrupted";
   messages: ReadonlyArray<{
     readonly ref: string;
+    readonly threadId?: string;
+    readonly runId?: string;
+    readonly runOutcome?: "completed" | "failed" | "interrupted";
     readonly role: "user" | "assistant";
     readonly text: string;
   }>;
 }
 
 export function buildKnowledgeCandidatesPrompt(input: KnowledgeCandidatesPromptInput) {
+  const threads = new Map<string, string>();
+  const runs = new Map<string, string>();
+  for (const message of input.messages) {
+    if (message.threadId !== undefined && !threads.has(message.threadId))
+      threads.set(message.threadId, `T${threads.size + 1}`);
+    if (message.runId !== undefined && !runs.has(message.runId))
+      runs.set(message.runId, `R${runs.size + 1}`);
+  }
   const prompt = [
-    "You review one finished exchange between a user and a coding agent and extract durable project knowledge a future agent working in this repository should know.",
+    "You review a bounded batch of new finished exchanges from one project thread family and extract durable project knowledge a future agent working in this repository should know.",
     "Return a JSON object with key candidates: an array of at most 3 objects with keys kind, content, entities, citations.",
     "Rules:",
     "- kind is one of decision, constraint, convention",
@@ -507,6 +518,8 @@ export function buildKnowledgeCandidatesPrompt(input: KnowledgeCandidatesPromptI
     "- content is one or two plain sentences that stand alone without this conversation",
     "- entities lists up to 5 short names of files, modules, tools, or concepts the knowledge is about",
     "- citations lists the refs (like M1) of the messages that state or directly support it; never invent a ref",
+    "- assistant-only claims need independent supporting messages from different completed runs and threads; repeated assertions from one agent are insufficient",
+    "- for failed or interrupted runs extract only what the user stated, not what the agent assumed",
     "- return an empty candidates array when nothing durable was established, which is the common case",
     ...(input.runOutcome === "completed"
       ? []
@@ -515,7 +528,10 @@ export function buildKnowledgeCandidatesPrompt(input: KnowledgeCandidatesPromptI
         ]),
     "",
     "Messages:",
-    ...input.messages.map((message) => `[${message.ref}] ${message.role}:\n${message.text}\n`),
+    ...input.messages.map(
+      (message) =>
+        `[${message.ref}] ${message.role}${message.runId === undefined ? "" : ` (${threads.get(message.threadId ?? "") ?? "T?"}/${runs.get(message.runId)}, ${message.runOutcome ?? input.runOutcome})`}:\n${message.text}\n`,
+    ),
   ].join("\n");
   const outputSchema = Schema.Struct({
     candidates: Schema.Array(

From fb5f5c0ffacac6e0369cdd811f7bd19dc1513d88 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 17:59:52 -0800
Subject: [PATCH 2/2] fix(memory): align replay fixtures and migration
 assertions

---
 apps/server/src/orchestration-v2/ProviderTurnStartService.ts  | 3 +--
 .../src/orchestration-v2/testkit/ProviderReplayHarness.ts     | 1 +
 .../src/persistence/reconcileV2PreviewMigration.test.ts       | 2 ++
 apps/server/src/project/knowledge/HolographicMemory.test.ts   | 4 ++--
 apps/server/src/provider/agentContextBudget.json              | 2 +-
 5 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/apps/server/src/orchestration-v2/ProviderTurnStartService.ts b/apps/server/src/orchestration-v2/ProviderTurnStartService.ts
index 98cc71391acf3..c2b500d2ebed9 100644
--- a/apps/server/src/orchestration-v2/ProviderTurnStartService.ts
+++ b/apps/server/src/orchestration-v2/ProviderTurnStartService.ts
@@ -1648,8 +1648,7 @@ export const layer: Layer.Layer<
         const budget = handoffBudgetAssumptions({
           tokenCap,
           modelContextWindow,
-          userText:
-            turnNotes === "" ? composer.baseText : `${turnNotes}\n\n${composer.baseText}`,
+          userText: turnNotes === "" ? composer.baseText : `${turnNotes}\n\n${composer.baseText}`,
           attachments: message.attachments,
           providerThread: budgetProviderThread,
           nativeContextEstimate:
diff --git a/apps/server/src/orchestration-v2/testkit/ProviderReplayHarness.ts b/apps/server/src/orchestration-v2/testkit/ProviderReplayHarness.ts
index 8723fabda85e2..73204eef07a5a 100644
--- a/apps/server/src/orchestration-v2/testkit/ProviderReplayHarness.ts
+++ b/apps/server/src/orchestration-v2/testkit/ProviderReplayHarness.ts
@@ -531,6 +531,7 @@ export function layerWithRegistry<Error>(
         Layer.mock(ProjectKnowledge.ProjectKnowledge)({
           nativeDeliveryEstimate: () => Effect.succeed(0),
           readSentDeliveries: () => Effect.succeed([]),
+          suggest: () => Effect.succeed([]),
         }),
         layerContextHandoffServiceProvided,
         layerEventSinkProvided,
diff --git a/apps/server/src/persistence/reconcileV2PreviewMigration.test.ts b/apps/server/src/persistence/reconcileV2PreviewMigration.test.ts
index 5ce01dedc80cd..ee986af24a4e6 100644
--- a/apps/server/src/persistence/reconcileV2PreviewMigration.test.ts
+++ b/apps/server/src/persistence/reconcileV2PreviewMigration.test.ts
@@ -72,6 +72,7 @@ describe("V2 preview upgrade", () => {
         [90, "ScheduledTaskThreadMode"],
         [91, "DropProjectLoomIndexes"],
         [92, "ProjectKnowledgeSavedLifecycle"],
+        [93, "ProjectKnowledgeLearningQueue"],
       ]);
       assert.deepStrictEqual(yield* runMigrations(), []);
       assert.deepStrictEqual(yield* sql`SELECT * FROM orchestration_v2_legacy_imports`, imports);
@@ -187,6 +188,7 @@ describe("V2 preview upgrade", () => {
         [90, "ScheduledTaskThreadMode"],
         [91, "DropProjectLoomIndexes"],
         [92, "ProjectKnowledgeSavedLifecycle"],
+        [93, "ProjectKnowledgeLearningQueue"],
       ]);
     }).pipe(Effect.provide(NodeSqliteClient.layer({ filename: ":memory:" }))),
   );
diff --git a/apps/server/src/project/knowledge/HolographicMemory.test.ts b/apps/server/src/project/knowledge/HolographicMemory.test.ts
index 0e8aef4a8e390..ae9ab0e6d7983 100644
--- a/apps/server/src/project/knowledge/HolographicMemory.test.ts
+++ b/apps/server/src/project/knowledge/HolographicMemory.test.ts
@@ -23,12 +23,12 @@ const candidate = (
   ...overrides,
 });
 
-it("retains the distinct ASCII search tokenizer", () => {
+it("retains Unicode words in the distinct search tokenizer", () => {
   assert.deepEqual(
     projectMemorySearchTokens(
       "The AND a src/lib.rs crate::Thing foo.bar _ GrüßE 東京 SQLite sqlite",
     ),
-    ["and", "crate::thing", "foo.bar", "gr", "sqlite", "src/lib.rs", "the"],
+    ["and", "crate::thing", "foo.bar", "grüße", "sqlite", "src/lib.rs", "the", "東京"],
   );
 });
 
diff --git a/apps/server/src/provider/agentContextBudget.json b/apps/server/src/provider/agentContextBudget.json
index a546d2e6827bd..a133094097764 100644
--- a/apps/server/src/provider/agentContextBudget.json
+++ b/apps/server/src/provider/agentContextBudget.json
@@ -1,5 +1,5 @@
 {
   "claudeSystemAppendBytes": 8824,
   "codexAdditionalContextBytes": 10550,
-  "mcpToolListJsonBytes": 67801
+  "mcpToolListJsonBytes": 67687
 }