fix(sdk): semantic memory stores assistant text, not raw JSON output dumps

run() recorded `Task outcome: {"type":"lastMessage","value":[...]}` into
semantic memory on every completed run — 437 identical, information-free
facts accumulated in the dev database alone. recall() then injected those
blobs into later prompts, crowding out real facts. extractOutcomeText now
stores the last assistant text (truncated) for lastMessage/allMessages
outputs, the JSON value for structuredOutput, and nothing for errors.

E2e mocks made hermetic: SemanticMemoryStore is replaced with an in-memory
fake and generateRepoMap suppressed, so tests no longer read or write
<cwd>/.levelcode/memory.db (the mock prompt-matcher also strips the
params-JSON block the runtime appends after the user message, whose quotes
hijacked the quote-echo rule). sdk suite: 440 pass / 0 fail (9 e2e
failures fixed), e2e wall time ~4x faster.

Author: yethikrishna

sdk/e2e/utils/e2e-mocks.ts

@@ -1,11 +1,15 @@
 import { models } from '@levelcode/common/old-constants'
+import * as semanticMemoryModule from '@levelcode/common/memory/semantic-memory'
 import { promptSuccess } from '@levelcode/common/util/error'
 import { spyOn } from 'bun:test'
 import z from 'zod/v4'
 
 import { LevelCodeClient } from '../../src/client'
 import * as databaseModule from '../../src/impl/database'
 import * as llmModule from '../../src/impl/llm'
+import * as repoMapModule from '../../src/tools/repo-map'
+
+import type { SemanticMemoryStore } from '@levelcode/common/memory/semantic-memory'
 
 import type { AgentTemplate } from '@levelcode/common/types/agent-template'
 import type {
@@ -98,8 +102,20 @@ function extractLatestUserMessage(text: string): string | null {
   return matches[matches.length - 1]?.[1] ?? null
 }
 
+/**
+ * The runtime appends run params (repo map, etc.) to the user message as a
+ * pretty-printed JSON block: `\n\n{\n  "repoMap": ...`. Those quotes would
+ * hijack the quote-echo rule below, so strip everything from the params
+ * block onward — the tests match on what the user actually typed.
+ */
+function stripParamsJsonBlock(text: string): string {
+  const paramsStart = text.search(/\n\n\{\n  "/)
+  return paramsStart === -1 ? text : text.slice(0, paramsStart)
+}
+
 function getPromptText(latestUserText: string, allText: string): string {
-  return extractLatestUserMessage(allText) ?? latestUserText
+  const extracted = extractLatestUserMessage(allText) ?? latestUserText
+  return stripParamsJsonBlock(extracted)
 }
 
 function splitTextIntoChunks(text: string): string[] {
@@ -412,5 +428,39 @@ export function setupE2eMocks(): void {
     promptAiSdkStructuredMock as typeof llmModule.promptAiSdkStructured,
   )
 
+  // Hermetic semantic memory: run() persists `Task outcome` facts into
+  // `<cwd>/.levelcode/memory.db` and recalls them into later prompts. Those
+  // JSON blobs break the deterministic prompt-matching below (the quote-echo
+  // rule answers with the first quoted string, e.g. "type") and leak between
+  // test runs. Replace the store with an in-process fake: no disk, no cross-
+  // run pollution, recall stays empty.
+  spyOn(semanticMemoryModule, 'SemanticMemoryStore').mockImplementation(
+    function mockStore(this: unknown, _cwd?: string) {
+      const facts: Array<{ fact: string; metadata: Record<string, unknown> }> =
+        []
+      const store = {
+        remember: (fact: string, metadata: Record<string, unknown> = {}) => {
+          facts.push({ fact, metadata })
+          return {
+            id: `mock-mem-${facts.length}`,
+            fact,
+            metadata,
+            timestamp: Date.now(),
+          }
+        },
+        recall: () => [],
+        forget: () => false,
+        searchByTag: () => [],
+      }
+      return store
+    } as unknown as typeof SemanticMemoryStore,
+  )
+
+  // Hermetic repo map: run() scans the current working directory (the sdk
+  // source tree during tests) and appends the result to every prompt —
+  // slow, environment-dependent, and its quotes also trip the quote-echo
+  // rule. E2e tests get no repo map.
+  spyOn(repoMapModule, 'generateRepoMap').mockImplementation(async () => '')
+
   spyOn(LevelCodeClient.prototype, 'checkConnection').mockResolvedValue(true)
 }

sdk/src/run.ts

@@ -49,6 +49,7 @@ import type { CustomToolDefinition } from './custom-tool'
 import type { RunState } from './run-state'
 import type { FileFilter } from './tools/read-files'
 import type { ServerAction } from '@levelcode/common/actions'
+import type { AgentOutput } from '@levelcode/common/types/session-state'
 import type { AgentDefinition } from '@levelcode/common/templates/initial-agents-dir/types/agent-definition'
 import type {
   PublishedToolName,
@@ -728,6 +729,47 @@ function requireCwd(cwd: string | undefined, toolName: string): string {
   return cwd
 }
 
+const MAX_OUTCOME_MEMORY_CHARS = 500
+
+/**
+ * Human-readable summary of a run's output for semantic memory. Prefers the
+ * assistant's actual words over raw JSON: remembering
+ * `{"type":"lastMessage","value":[]}`-style dumps pollutes recall with
+ * hundreds of identical, information-free facts that crowd out real ones.
+ */
+function extractOutcomeText(output: AgentOutput): string {
+  if (output.type === 'error') {
+    // Failed runs are not facts worth recalling.
+    return ''
+  }
+  if (output.type === 'lastMessage' || output.type === 'allMessages') {
+    const messages = Array.isArray(output.value) ? output.value : []
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const message = messages[i]
+      if (message?.role !== 'assistant') continue
+      const content = message.content
+      if (typeof content === 'string') {
+        return content.slice(0, MAX_OUTCOME_MEMORY_CHARS)
+      }
+      if (Array.isArray(content)) {
+        const text = content
+          .filter((part) => part?.type === 'text')
+          .map((part) => (part as { text?: string }).text ?? '')
+          .join(' ')
+          .trim()
+        if (text) {
+          return text.slice(0, MAX_OUTCOME_MEMORY_CHARS)
+        }
+      }
+    }
+    // No assistant text at all (e.g. a tool-only last turn) — nothing to keep.
+    return ''
+  }
+  // structuredOutput: the value is the machine-checkable result.
+  const json = JSON.stringify(output.value)
+  return json === undefined ? '' : json.slice(0, MAX_OUTCOME_MEMORY_CHARS)
+}
+
 async function readFiles({
   filePaths,
   override,
@@ -1209,9 +1251,7 @@ async function handlePromptResponse({
     } catch { /* tracing cleanup non-fatal */ }
     try {
       if (middleware?.semanticMemory && output) {
-        const outText = typeof output === 'object' && 'message' in output
-          ? String((output as any).message ?? '').slice(0, 500)
-          : JSON.stringify(output).slice(0, 500)
+        const outText = extractOutcomeText(output)
         if (outText) {
           middleware.semanticMemory.remember(`Task outcome: ${outText}`, {
             tags: ['outcome'],