feat(opencode): native auto-memory for cross-session learning by lleontor705 · Pull Request #20344 · anomalyco/opencode

lleontor705 · 2026-03-31T20:47:37Z

Issue for this PR

Closes#20322

Type of change

Bug fix
New feature
Refactor / code improvement
Documentation

What does this PR do?

Adds native auto-memory for cross-session learning. Currently OpenCode has no built-in way to persist patterns between sessions — users have to manually curate AGENTS.md. This PR adds a \memory\ module that automatically extracts useful patterns from session events and makes them available in future sessions.

How it works:

Extractor — observes tool calls and user messages during a session, detecting 5 pattern types: repeated build commands, error+fix sequences, user preferences, architecture decisions (multi-file edits), and config file changes
Store — saves extracted memories to a new \memory\ SQLite table with UPSERT deduplication by topic
MEMORY.md — auto-generated in .opencode/MEMORY.md\ at session end, grouped by type (atomic writes via tmp+rename)
Injector — reads MEMORY.md at session start and includes it in the system prompt (respecting \max_memory_lines)
Per-session state — extractor uses a Map keyed by sessionId to prevent state leaks between sessions
Debounced writes — SQLite writes are buffered and flushed every 3s or at session end, avoiding event loop blocking
Auto-gitignore — .opencode/MEMORY.md\ is automatically added to the project's .gitignore\
Configurable via { memory: { enabled: true, auto_extract: true, max_memory_lines: 200 } }\

All extraction is fire-and-forget and best-effort — it never blocks or affects session performance.

Related issues

[FEATURE] Persistent Session Memory #16077 — Simple memory for cross-session persistence
Feature Request: Model-Agnostic Memory Layer (Global & Per-Project) #8043 — Memory with embeddings + vector search (future Phase 2)
[FEATURE]: Advanced Dual-Scope Memory System for OpenCode #9211 — Dual-scope memory (global + project)

This PR is Phase 1 foundation: file-based extraction with LIKE search. Phase 2 can replace LIKE with vector embeddings in the \search()\ method without changing the extraction or injection layers.

How did you verify your code works?

21 unit tests covering store CRUD, UPSERT merge, all 5 extraction patterns, false positives, debounced saves, MEMORY.md file read/write/update, per-session state isolation, and abort controller leak detection
\�un test packages/opencode/test/memory/\ — all 21 pass
\�unx tsgo --noEmit\ in packages/opencode — 0 errors

Checklist

I have tested my changes locally
I have not included unrelated changes in this PR
PR targets the correct branch (\dev)

Copilot

Pull request overview

Adds a new “auto-memory” subsystem to packages/opencode to persist and re-inject cross-session learnings (via a SQLite memory table and an auto-generated .opencode/MEMORY.md) and wires it into session processing/prompt construction.

Changes:

Introduces a memory module (extractor, store, MEMORY.md writer, and prompt injector) plus a DB migration for the new memory table.
Hooks memory injection into the session system prompt and hooks extraction/update into the session processor.
Adds unit tests for the memory store/extractor/file behavior and removes an older memory-leak test.

Reviewed changes

Copilot reviewed 14 out of 14 changed files in this pull request and generated 15 comments.

Show a summary per file

File	Description
packages/opencode/src/session/prompt.ts	Injects `.opencode/MEMORY.md` content into the system prompt (bounded by `max_memory_lines`).
packages/opencode/src/session/processor.ts	Adds extractor hooks for tool call/result events and updates MEMORY.md (best-effort).
packages/opencode/src/memory/types.ts	Defines memory types and a `Memory` interface.
packages/opencode/src/memory/store.ts	Implements CRUD/search/compact for persisted memories.
packages/opencode/src/memory/memory.sql.ts	Defines the Drizzle schema for the `memory` table and indexes.
packages/opencode/src/memory/memory-file.ts	Generates and reads `.opencode/MEMORY.md` from stored memories.
packages/opencode/src/memory/injector.ts	Reads/trims MEMORY.md and returns it as system prompt content.
packages/opencode/src/memory/extractor.ts	Implements heuristic extraction from tool calls/results and user messages.
packages/opencode/src/memory/index.ts	Re-exports memory module surface.
packages/opencode/src/config/config.ts	Adds `memory` config block (enabled/auto_extract/max_memory_lines).
packages/opencode/migration/20260331180000_add_memory_table/migration.sql	Creates the `memory` table and indexes.
packages/opencode/test/memory/store.test.ts	Adds tests for store CRUD/compact and MemoryFile read/write/update.
packages/opencode/test/memory/extractor.test.ts	Adds tests for all extraction patterns and false positives.
packages/opencode/test/memory/abort-leak.test.ts	Removes prior abort-controller leak test.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-03-31T20:55:06Z

+ // Feed to memory extractor (fire-and-forget)
+ try { MemoryExtractor.onToolCall(value.toolName, value.input as Record<string, unknown>) } catch {}


Memory extraction is invoked for every tool call, but initialization is conditional on config. Because MemoryExtractor holds global state and is never reset in this flow, a previous session could leave state non-null and extraction would still run even when cfg.memory.enabled === false for the current session. Consider gating these calls on the same config check (or making the extractor state keyed by session and cleared on cleanup).
Suggested change
// Feed to memory extractor (fire-and-forget)
try{MemoryExtractor.onToolCall(value.toolName,value.inputasRecord<string,unknown>)}catch{}
// Feed to memory extractor (fire-and-forget), but only if memory extraction is enabled
constmemoryConfig=(Configasany).memory
if(!memoryConfig||memoryConfig.enabled){
try{
MemoryExtractor.onToolCall(value.toolName,value.inputasRecord<string,unknown>)
}catch{}
}

Copilot · 2026-03-31T20:55:06Z

+ const exitCode = (value.output.metadata as Record<string, unknown>)?.exitCode as number | undefined
+ MemoryExtractor.onToolResult(
+ match.tool,
+ (value.input ?? match.state.input) as Record<string, unknown>,
+ value.output.output,
+ exitCode,
+ )
+ } catch {}


exitCode is read from value.output.metadata.exitCode, but the bash tool appears to emit metadata.exit (see tool/bash.ts). As a result, exitCode will be undefined and error-solution detection based on non-zero exit codes will never trigger in real sessions. Update the metadata key (and handle null vs number from proc.exitCode) so the extractor receives correct exit status.
Suggested change
constexitCode=(value.output.metadataasRecord<string,unknown>)?.exitCodeasnumber|undefined
MemoryExtractor.onToolResult(
match.tool,
(value.input??match.state.input)asRecord<string,unknown>,
value.output.output,
exitCode,
)
}catch{}
constmetadata=value.output.metadataasRecord<string,unknown>|undefined
constrawExit=metadata&&(metadataasRecord<string,unknown>)["exit"]
letexitCode: number|undefined
if(typeofrawExit==="number"){
exitCode=rawExit
}elseif(rawExit===null){
exitCode=undefined
}
MemoryExtractor.onToolResult(
match.tool,
(value.input??match.state.input)asRecord<string,unknown>,
value.output.output,
exitCode,
)
}catch(error){
Log.error("MemoryExtractor.onToolResult failed",error)
}

Copilot · 2026-03-31T20:55:06Z

+ // Update MEMORY.md from extracted memories (best-effort)
+ try {
+ const cfg = yield* config.get()
+ if (cfg.memory?.enabled !== false && cfg.memory?.auto_extract !== false) {
+ yield* Effect.promise(() => MemoryFile.updateMemoryFile(Instance.directory))
+ }


cleanup() runs after each assistant message processing attempt (via Effect.ensuring(cleanup())), so MemoryFile.updateMemoryFile(...) will execute repeatedly during a session rather than “at session end” as described. This can add avoidable IO and churn, and may rewrite MEMORY.md even when no new memories were extracted. Consider deferring the update to a session-idle/finalizer point, or tracking a “dirty” flag in the extractor/store to update only when needed.

Copilot · 2026-03-31T20:55:07Z

+ // Initialize memory extractor
+ try {
+ const cfg = yield* config.get()
+ if (cfg.memory?.enabled !== false && cfg.memory?.auto_extract !== false) {
+ MemoryExtractor.init(Instance.directory, ctx.sessionID)
+ }
+ } catch {
+ // Memory extraction is best-effort
+ }


MemoryExtractor is initialized inside process() for each assistant generation. Since the extractor is a module-level singleton, this design is not safe if multiple sessions/processors run concurrently (state will be overwritten and tool calls from different sessions can interleave). Consider making the extractor state per-session (e.g., Map keyed by sessionID) or instantiating an extractor per SessionProcessor.create() handle.

Copilot · 2026-03-31T20:55:07Z

+export namespace MemoryExtractor {
+ let state: ExtractorState | null = null
+
+ export function init(projectPath: string, sessionId?: string) {
+ state = {
+ bashCommandCount: new Map(),
+ lastToolCalls: [],
+ currentTurnEdits: new Set(),
+ projectPath,
+ sessionId,
+ detectedTopics: new Set(),
+ }
+ }
+
+ export function reset() {
+ state = null
+ }
+
+ export function onToolCall(tool: string, input: Record<string, unknown>) {


MemoryExtractor is implemented as a singleton (let state: ExtractorState | null = null). Given the session processor can run multiple sessions concurrently, this shared mutable state can cause cross-session contamination and race conditions. Refactor to keep state per session (e.g., Map<SessionID, ExtractorState> with explicit sessionID passed to hooks) or return an extractor instance from init() that is stored on the processor context.
Suggested change
exportnamespaceMemoryExtractor{
letstate: ExtractorState|null=null
exportfunctioninit(projectPath: string,sessionId?: string){
state={
bashCommandCount: newMap(),
lastToolCalls: [],
currentTurnEdits: newSet(),
projectPath,
sessionId,
detectedTopics: newSet(),
}
}
exportfunctionreset(){
state=null
}
exportfunctiononToolCall(tool: string,input: Record<string,unknown>){
constDEFAULT_SESSION_ID="__default__"
exportnamespaceMemoryExtractor{
conststateBySession=newMap<string,ExtractorState>()
functiongetSessionId(sessionId?: string): string{
returnsessionId??DEFAULT_SESSION_ID
}
functiongetState(sessionId?: string): ExtractorState|undefined{
constid=getSessionId(sessionId)
returnstateBySession.get(id)
}
functionensureState(projectPath: string,sessionId?: string): ExtractorState{
constid=getSessionId(sessionId)
letstate=stateBySession.get(id)
if(!state){
state={
bashCommandCount: newMap(),
lastToolCalls: [],
currentTurnEdits: newSet(),
projectPath,
sessionId,
detectedTopics: newSet(),
}
stateBySession.set(id,state)
}
returnstate
}
exportfunctioninit(projectPath: string,sessionId?: string){
ensureState(projectPath,sessionId)
}
exportfunctionreset(sessionId?: string){
if(sessionId){
stateBySession.delete(getSessionId(sessionId))
}else{
stateBySession.clear()
}
}
exportfunctiononToolCall(sessionId: string|undefined,tool: string,input: Record<string,unknown>){
conststate=getState(sessionId)

Copilot · 2026-03-31T20:55:08Z

+CREATE TABLE `memory` (
+	`id` text PRIMARY KEY NOT NULL,
+	`project_path` text NOT NULL,
+	`type` text NOT NULL,
+	`topic` text NOT NULL,
+	`content` text NOT NULL,
+	`session_id` text,
+	`access_count` integer DEFAULT 0 NOT NULL,
+	`time_created` integer NOT NULL,
+	`time_updated` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX `memory_project_topic_idx` ON `memory` (`project_path`, `topic`);
+--> statement-breakpoint
+CREATE INDEX `memory_project_idx` ON `memory` (`project_path`);
+--> statement-breakpoint
+CREATE INDEX `memory_type_idx` ON `memory` (`type`);


The new memory table migration does not enforce topic deduplication (no UNIQUE constraint). If topic-level dedupe is required, add a unique index/constraint on (project_path, topic) and update the store to upsert accordingly.

Copilot · 2026-03-31T20:55:09Z

+ try { db.run(`DELETE FROM memory`).run() } catch {}
+ })
+
+ afterEach(() => {
+ const db = Database.Client()
+ try { db.run(`DELETE FROM memory`).run() } catch {}


Database.Client().run(...) already executes the SQL; chaining an extra .run() (db.run(...).run()) is inconsistent with other tests (e.g. account repo tests) and will likely throw (then get swallowed by the try/catch), leaving the memory table uncleared and making these tests order-dependent. Drop the extra .run() and avoid swallowing errors here so failures are visible.
Suggested change
try{db.run(`DELETE FROM memory`).run()}catch{}
})
afterEach(()=>{
constdb=Database.Client()
try{db.run(`DELETE FROM memory`).run()}catch{}
db.run(`DELETE FROM memory`)
})
afterEach(()=>{
constdb=Database.Client()
db.run(`DELETE FROM memory`)

Copilot · 2026-03-31T20:55:09Z

+ try { db.run(`DELETE FROM memory`).run() } catch {}
+ MemoryExtractor.init(projectPath, "test-session")
+ })
+
+ afterEach(() => {
+ const db = Database.Client()
+ try { db.run(`DELETE FROM memory`).run() } catch {}


Same issue as in store.test.ts: db.run(...).run() is likely incorrect and the try/catch {} will silently skip DB cleanup if it throws, making tests flaky. Prefer db.run(sql) and let errors surface so test setup failures are caught.
Suggested change
try{db.run(`DELETE FROM memory`).run()}catch{}
MemoryExtractor.init(projectPath,"test-session")
})
afterEach(()=>{
constdb=Database.Client()
try{db.run(`DELETE FROM memory`).run()}catch{}
db.run(`DELETE FROM memory`)
MemoryExtractor.init(projectPath,"test-session")
})
afterEach(()=>{
constdb=Database.Client()
db.run(`DELETE FROM memory`)

Copilot · 2026-03-31T20:55:09Z

+ test("updateMemoryFile creates file from store", async () => {
+ // We need to insert into the DB first
+ const db = Database.Client()
+ try { db.run(`DELETE FROM memory`).run() } catch {}
+ MemoryStore.save({ projectPath: tmpDir, type: "preference", topic: "t1", content: "use spaces" })
+


DB cleanup in this test uses db.run(...).run() inside a try/catch {}; if the chained .run() is invalid, cleanup is skipped silently. Use db.run(sql) (no chaining) and avoid swallowing errors so the test reliably starts from a clean table.

Copilot · 2026-03-31T20:55:10Z

+ .object({
+ enabled: z.boolean().default(true).describe("Enable auto-memory for cross-session learning"),
+ auto_extract: z.boolean().default(true).describe("Automatically extract memories from session events"),
+ max_memory_lines: z.number().default(200).describe("Maximum lines of memory to inject into system prompt"),


max_memory_lines is defined as z.number().default(200) without .int().positive().min(0) guards. Negative or fractional values would lead to confusing trimming behavior (e.g., slice(0, -5) drops lines). Consider validating this as a non-negative integer (similar to other numeric config fields).
Suggested change
max_memory_lines: z.number().default(200).describe("Maximum lines of memory to inject into system prompt"),
max_memory_lines: z
.number()
.int()
.min(0)
.default(200)
.describe("Maximum lines of memory to inject into system prompt"),

lleontor705 · 2026-04-01T06:33:06Z

CI Status Note

The failing checks are pre-existing upstream issues, unrelated to this PR:

e2e (linux/windows): Requires \OPENCODE_API_KEY\ — not available in CI
unit (linux/windows): \processor-effect\ tests broken upstream (not memory-related)
typecheck: Enterprise package type error, unrelated to memory

All 19 new memory tests pass (extractor + store + memory-file).

Phase 1 Positioning

This PR provides the minimal infrastructure for:

[FEATURE] Persistent Session Memory #16077 (file-based memory): the MEMORY.md generation + injection pipeline
Feature Request: Model-Agnostic Memory Layer (Global & Per-Project) #8043 (embedding memory): the store layer that vector search would replace \LIKE\ in
[FEATURE]: Advanced Dual-Scope Memory System for OpenCode #9211 (dual-scope): the per-project storage that global scope would extend

Phase 2 additions (embeddings, global scope, LLM-assisted extraction) build directly on this store/injector layer.

…n, remove nanoid dep

…ries

- Add debounced writes (3s buffer) to avoid SQLite writes on every tool call - Add UPSERT in save() to merge duplicate memories on same topic+project - Tighten preference detector: require 2+ pattern matches (was 1, too noisy) - Improve normalizeCommand() to preserve first positional arg - Add MemoryExtractor.flushPending() + reset() call in session cleanup - Update MEMORY.md header: user edits preserved, gitignore guidance added - Add 3 new tests: debounce buffer, flush on reset, single-pattern false positive - Update store test for UPSERT merge behavior (19/19 pass)

- Replace global singleton state with Map keyed by sessionId to prevent state leaks when sessions overlap - Add try/catch in reset() to ensure cleanup even on flush errors - Simplify normalizeCommand() to keep command name + first 2 args instead of confusing lastFlagIdx tracking

…Access - Use Database.transaction callback parameter directly instead of wrapping Database.use() inside, matching codebase patterns (session/todo, sync) - Remove incrementAccess() which is never called anywhere - Truncate input content to 200 chars before merge to keep UPSERT bounded

- Write to temp file then rename instead of direct write to prevent corruption on crash - Append .opencode/MEMORY.md to existing .gitignore files (don't create .gitignore if it doesn't exist)

- Replace empty catch blocks with log.debug() for memory extraction errors so issues are visible during debugging

Replace test for removed incrementAccess() with test verifying UPSERT access_count increment behavior

Implements cross-session persistent memory (Issues #43, #44, #45) and fixes GLM-5.1 thinking output corruption (Issue #52). Memory system: SQLite + file-based storage with auto-extraction and session-start injection, schema aligned with upstream PR anomalyco#20344. GLM fix: model-specific prompt, think tag parsing utility, and streaming repetition loop detection to prevent context exhaustion. Closes#43, Closes#44, Closes#45, Relates #52 Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

CopilotAI review requested due to automatic review settings March 31, 2026 20:47

Copilotstarted reviewing on behalf of lleontor705 March 31, 2026 20:48 View session

CopilotAI reviewed Mar 31, 2026
View reviewed changes

lleontor705 added 10 commits April 1, 2026 06:05

feat: add auto-memory for persistent cross-session learning
5b8d4b9

fix: resolve memory test failures — extractor error-solution detectio…
c35c5b4
…n, remove nanoid dep

fix: add session-end hook to regenerate MEMORY.md from extracted memo…
4ca992b
…ries

fix: add missing Instance import, fix timing-sensitive test
65ba884

fix(memory): atomic file writes and auto-gitignore for MEMORY.md
e5bb1d2
- Write to temp file then rename instead of direct write to prevent corruption on crash - Append .opencode/MEMORY.md to existing .gitignore files (don't create .gitignore if it doesn't exist)

fix(memory): add debug logging to silent catch blocks in processor
992e268
- Replace empty catch blocks with log.debug() for memory extraction errors so issues are visible during debugging

test(memory): update store test for removed incrementAccess
5569c2e
Replace test for removed incrementAccess() with test verifying UPSERT access_count increment behavior

lleontor705 force-pushed the feat/auto-memory branch from d3e7d91 to 5569c2eCompare April 1, 2026 11:05

lleontor705 added 3 commits April 1, 2026 06:14

fix: resolve TypeScript errors from previous fixes
5271693

fix: restore abort-leak test from upstream (anomalyco#12024)
556b820

fix: restore branded types in abort-leak test (SessionID, MessageID)
814c646

tobias-weiss-ai-xr mentioned this pull request Apr 1, 2026
feat: add context visualization, memory system, cron scheduler, and bash semantics #20454
Closed

terisuke mentioned this pull request Apr 5, 2026
fix: memory type enum alignment with upstream PR #20344 Cor-Incorporated/opencode#54
Closed

terisuke mentioned this pull request Apr 5, 2026
feat(opencode): add memory system and GLM thinking corruption fix Cor-Incorporated/opencode#56
Merged
3 tasks

terisuke mentioned this pull request Apr 8, 2026
epic: internal AI guardrails thin distribution for Cor-Incorporated Cor-Incorporated/opencode#1
Open

github-actionsBot mentioned this pull request Apr 8, 2026
feat(session): harden per-session SQLite sharding #21579
Closed
6 tasks

opencode-agentBotforce-pushed the dev branch from 2f2ed11 to 9f201d6Compare April 16, 2026 21:55

github-actionsBot mentioned this pull request Aug 23, 2026
feat: project memory layer (tool + system context source) #44539
Closed

Navigation Menu

Uh oh!

feat(opencode): native auto-memory for cross-session learning - #20344

feat(opencode): native auto-memory for cross-session learning#20344
lleontor705 wants to merge 13 commits into
anomalyco:devfrom
lleontor705:feat/auto-memory

lleontor705 commented Mar 31, 2026•
edited
Loading

Uh oh!

CopilotAI left a comment

Uh oh!

CopilotAIMar 31, 2026

Uh oh!

CopilotAIMar 31, 2026

Uh oh!

CopilotAIMar 31, 2026

Uh oh!

CopilotAIMar 31, 2026

Uh oh!

CopilotAIMar 31, 2026

Uh oh!

CopilotAIMar 31, 2026

Uh oh!

CopilotAIMar 31, 2026

Uh oh!

CopilotAIMar 31, 2026

Uh oh!

CopilotAIMar 31, 2026

Uh oh!

CopilotAIMar 31, 2026

Uh oh!

lleontor705 commented Apr 1, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

		// Feed to memory extractor (fire-and-forget)
		try { MemoryExtractor.onToolCall(value.toolName, value.input as Record<string, unknown>) } catch {}

-// Feed to memory extractor (fire-and-forget)
-try{MemoryExtractor.onToolCall(value.toolName,value.inputasRecord<string,unknown>)}catch{}
+// Feed to memory extractor (fire-and-forget), but only if memory extraction is enabled
+constmemoryConfig=(Configasany).memory
+if(!memoryConfig||memoryConfig.enabled){
+try{
+MemoryExtractor.onToolCall(value.toolName,value.inputasRecord<string,unknown>)
+}catch{}
+}

-constexitCode=(value.output.metadataasRecord<string,unknown>)?.exitCodeasnumber|undefined
-MemoryExtractor.onToolResult(
-match.tool,
-(value.input??match.state.input)asRecord<string,unknown>,
-value.output.output,
-exitCode,
-)
-}catch{}
+constmetadata=value.output.metadataasRecord<string,unknown>|undefined
+constrawExit=metadata&&(metadataasRecord<string,unknown>)["exit"]
+letexitCode: number|undefined
+if(typeofrawExit==="number"){
+exitCode=rawExit
+}elseif(rawExit===null){
+exitCode=undefined
+}
+MemoryExtractor.onToolResult(
+match.tool,
+(value.input??match.state.input)asRecord<string,unknown>,
+value.output.output,
+exitCode,
+)
+}catch(error){
+Log.error("MemoryExtractor.onToolResult failed",error)
+}

-exportnamespaceMemoryExtractor{
-letstate: ExtractorState|null=null
-exportfunctioninit(projectPath: string,sessionId?: string){
-state={
-bashCommandCount: newMap(),
-lastToolCalls: [],
-currentTurnEdits: newSet(),
-projectPath,
-sessionId,
-detectedTopics: newSet(),
-}
-}
-exportfunctionreset(){
-state=null
-}
-exportfunctiononToolCall(tool: string,input: Record<string,unknown>){
+constDEFAULT_SESSION_ID="__default__"
+exportnamespaceMemoryExtractor{
+conststateBySession=newMap<string,ExtractorState>()
+functiongetSessionId(sessionId?: string): string{
+returnsessionId??DEFAULT_SESSION_ID
+}
+functiongetState(sessionId?: string): ExtractorState|undefined{
+constid=getSessionId(sessionId)
+returnstateBySession.get(id)
+}
+functionensureState(projectPath: string,sessionId?: string): ExtractorState{
+constid=getSessionId(sessionId)
+letstate=stateBySession.get(id)
+if(!state){
+state={
+bashCommandCount: newMap(),
+lastToolCalls: [],
+currentTurnEdits: newSet(),
+projectPath,
+sessionId,
+detectedTopics: newSet(),
+}
+stateBySession.set(id,state)
+}
+returnstate
+}
+exportfunctioninit(projectPath: string,sessionId?: string){
+ensureState(projectPath,sessionId)
+}
+exportfunctionreset(sessionId?: string){
+if(sessionId){
+stateBySession.delete(getSessionId(sessionId))
+}else{
+stateBySession.clear()
+}
+}
+exportfunctiononToolCall(sessionId: string|undefined,tool: string,input: Record<string,unknown>){
+conststate=getState(sessionId)

-try{db.run(`DELETE FROM memory`).run()}catch{}
-})
-afterEach(()=>{
-constdb=Database.Client()
-try{db.run(`DELETE FROM memory`).run()}catch{}
+db.run(`DELETE FROM memory`)
+})
+afterEach(()=>{
+constdb=Database.Client()
+db.run(`DELETE FROM memory`)

Uh oh!

Conversation

lleontor705 commented Mar 31, 2026• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Issue for this PR

Type of change

What does this PR do?

Related issues

How did you verify your code works?

Checklist

Uh oh!

CopilotAI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

CopilotAIMar 31, 2026

Choose a reason for hiding this comment

Uh oh!

CopilotAIMar 31, 2026

Choose a reason for hiding this comment

Uh oh!

CopilotAIMar 31, 2026

Choose a reason for hiding this comment

Uh oh!

CopilotAIMar 31, 2026

Choose a reason for hiding this comment

Uh oh!

CopilotAIMar 31, 2026

Choose a reason for hiding this comment

Uh oh!

CopilotAIMar 31, 2026

Choose a reason for hiding this comment

Uh oh!

CopilotAIMar 31, 2026

Choose a reason for hiding this comment

Uh oh!

CopilotAIMar 31, 2026

Choose a reason for hiding this comment

Uh oh!

CopilotAIMar 31, 2026

Choose a reason for hiding this comment

Uh oh!

CopilotAIMar 31, 2026

Choose a reason for hiding this comment

Uh oh!

lleontor705 commented Apr 1, 2026

CI Status Note

Phase 1 Positioning

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

lleontor705 commented Mar 31, 2026•
edited
Loading