การปรับโครงสร้างสถานะโดยยึดฐานข้อมูลเป็นหลัก

ข้อสรุป

ใช้โครงสร้าง SQLite สองระดับ:

• ฐานข้อมูลส่วนกลาง: ~/.openclaw/state/openclaw.sqlite
• ฐานข้อมูลเอเจนต์: ฐานข้อมูล SQLite หนึ่งฐานต่อเอเจนต์สำหรับพื้นที่ทำงานที่เอเจนต์เป็นเจ้าของ บันทึกบทสนทนา VFS อาร์ติแฟกต์ และสถานะรันไทม์ขนาดใหญ่เฉพาะเอเจนต์
• การกำหนดค่ายังคงใช้ไฟล์เป็นที่จัดเก็บ: openclaw.json ยังคงอยู่นอก ฐานข้อมูล โปรไฟล์การยืนยันตัวตนของรันไทม์ย้ายไปยัง SQLite ส่วนไฟล์ข้อมูลประจำตัว ของผู้ให้บริการภายนอกหรือ CLI ยังคงให้เจ้าของจัดการภายนอกฐานข้อมูลของ OpenClaw

ฐานข้อมูลส่วนกลางคือฐานข้อมูลของระนาบควบคุม โดยเป็นเจ้าของการค้นพบเอเจนต์ สถานะ Gateway ที่ใช้ร่วมกัน การจับคู่ สถานะอุปกรณ์/Node บัญชีแยกประเภทของงานและโฟลว์ สถานะ Plugin สถานะรันไทม์ของตัวจัดกำหนดการ เมทาดาทาการสำรองข้อมูล และสถานะการย้ายข้อมูล

ฐานข้อมูลเอเจนต์คือฐานข้อมูลของระนาบข้อมูล โดยเป็นเจ้าของเมทาดาทาเซสชันของเอเจนต์ สตรีมเหตุการณ์บันทึกบทสนทนา พื้นที่ทำงาน VFS หรือเนมสเปซชั่วคราว อาร์ติแฟกต์ของเครื่องมือ อาร์ติแฟกต์การรัน และข้อมูลแคชภายในเอเจนต์ที่ค้นหาและสร้างดัชนีได้

แนวทางนี้ให้มุมมองส่วนกลางที่คงทนหนึ่งชุด โดยไม่บังคับให้พื้นที่ทำงานของเอเจนต์ขนาดใหญ่ บันทึกบทสนทนา และข้อมูลไบนารีชั่วคราวเข้าสู่ช่องทางการเขียนของ Gateway ที่ใช้ร่วมกัน

สัญญาที่เคร่งครัด

การย้ายข้อมูลนี้มีรูปแบบรันไทม์มาตรฐานเพียงรูปแบบเดียว:

• แถวเซสชันจัดเก็บเฉพาะเมทาดาทาเซสชันเท่านั้น ต้องไม่จัดเก็บ transcriptLocator พาธไฟล์บันทึกบทสนทนา พาธ JSONL ข้างเคียง พาธล็อก เมทาดาทาการตัดแต่ง หรือพอยน์เตอร์ความเข้ากันได้จากยุคที่ใช้ไฟล์
• อัตลักษณ์ของบันทึกบทสนทนาเป็นอัตลักษณ์ SQLite เสมอ: {agentId, sessionId} พร้อม เมทาดาทาหัวข้อแบบไม่บังคับในกรณีที่โปรโตคอลจำเป็นต้องใช้
• sqlite-transcript://... ไม่ใช่อัตลักษณ์ของรันไทม์หรือโปรโตคอล โค้ดใหม่ต้อง ไม่สร้าง จัดเก็บ ส่ง แยกวิเคราะห์ หรือย้ายตัวระบุตำแหน่งบันทึกบทสนทนา รันไทม์และ การทดสอบไม่ควรมีตัวระบุตำแหน่งจำลองใด ๆ เลย เอกสารอาจกล่าวถึงสตริงนี้ ได้เฉพาะเพื่อระบุข้อห้าม
• sessions.json แบบเดิม, JSONL ของบันทึกบทสนทนา, .jsonl.lock, การตัดแต่ง, การตัดทอน และตรรกะพาธเซสชันแบบเก่า เป็นของพาธการย้าย/นำเข้าผ่าน doctor เท่านั้น
• นามแฝงการกำหนดค่าเซสชันแบบเดิมเป็นของการย้ายข้อมูลผ่าน doctor เท่านั้น รันไทม์ ไม่ตีความ session.idleMinutes, session.resetByType.dm หรือ นามแฝงเซสชันหลัก agent:main:* ข้ามเอเจนต์สำหรับเอเจนต์อื่นที่กำหนดค่าไว้
• อัตลักษณ์การกำหนดเส้นทางเซสชันเป็นสถานะแบบเชิงสัมพันธ์ที่มีชนิดกำกับ พาธรันไทม์ที่ใช้งานหนักและพาธ UI ควรอ่าน sessions.session_scope, sessions.account_id, sessions.primary_conversation_id, conversations และ session_conversations โดยต้องไม่แยกวิเคราะห์ session_key หรือขุดค้น session_entries.entry_json เพื่อหาอัตลักษณ์ผู้ให้บริการ ยกเว้นในฐานะ เงาความเข้ากันได้ระหว่างที่กำลังลบจุดเรียกใช้งานเก่า
• เครื่องหมายข้อความโดยตรงระดับช่องทาง เช่น dm เทียบกับ direct เป็นคำศัพท์ สำหรับการกำหนดเส้นทาง ไม่ใช่ตัวระบุตำแหน่งบันทึกบทสนทนาหรือแฮนเดิลความเข้ากันได้ของที่จัดเก็บแบบไฟล์
• การกำหนดค่าตัวจัดการฮุกแบบเดิมเป็นของพื้นผิวการเตือน/ย้ายข้อมูลของ doctor เท่านั้น รันไทม์ต้องไม่โหลด hooks.internal.handlers ฮุกทำงานผ่านไดเรกทอรีฮุก ที่ค้นพบและเมทาดาทา HOOK.md เท่านั้น
• การเริ่มต้นรันไทม์ พาธตอบกลับที่ใช้งานหนัก Compaction การรีเซ็ต การกู้คืน การวินิจฉัย TTS ฮุกหน่วยความจำ เอเจนต์ย่อย การกำหนดเส้นทางคำสั่ง Plugin ขอบเขตโปรโตคอล และ ฮุก ต้องส่ง {agentId, sessionId} ผ่านรันไทม์
• การทดสอบควรเตรียมและตรวจยืนยันแถวบันทึกบทสนทนา SQLite ผ่าน {agentId, sessionId} ควรลบการทดสอบที่พิสูจน์เพียงการส่งต่อพาธ JSONL การคงตัวระบุตำแหน่งที่ผู้เรียกส่งมา หรือความเข้ากันได้กับไฟล์บันทึกบทสนทนา เว้นแต่จะครอบคลุมการนำเข้าผ่าน doctor การสร้างข้อมูลประกอบสำหรับการสนับสนุน/ดีบัก ที่ไม่ใช่เซสชัน หรือรูปแบบโปรโตคอล
• runEmbeddedPiAgent(...) การรันของเวิร์กเกอร์ที่เตรียมไว้ และความพยายามแบบฝังตัว ภายใน ต้องไม่รับตัวระบุตำแหน่งบันทึกบทสนทนา โดยเปิดตัวจัดการบันทึกบทสนทนา SQLite ด้วย {agentId, sessionId} และส่งตัวจัดการนั้นไปยังเซสชันเอเจนต์ ที่เข้ากันได้กับ PI ซึ่งรวมไว้ภายใน เพื่อไม่ให้ผู้เรียกที่ล้าสมัยทำให้รันเนอร์เขียน บันทึกบทสนทนา JSON/JSONL ได้
• การวินิจฉัยของรันเนอร์ต้องจัดเก็บระเบียนการติดตามรันไทม์/แคช/เพย์โหลดใน SQLite การวินิจฉัยรันไทม์ต้องไม่เปิดเผยตัวเลือกแทนที่ไฟล์ JSONL หรือเครื่องมือช่วยส่งออก JSONL ของบันทึกบทสนทนาแบบทั่วไป การส่งออกที่ผู้ใช้มองเห็นสามารถสร้างอาร์ติแฟกต์ ที่ระบุชัดจากแถวฐานข้อมูลได้โดยไม่ส่งชื่อไฟล์กลับเข้าสู่รันไทม์
• การบันทึกสตรีมดิบใช้ OPENCLAW_RAW_STREAM=1 ร่วมกับแถวการวินิจฉัย SQLite สัญญาตัวบันทึกไฟล์ pi-mono แบบเก่า ได้แก่ PI_RAW_STREAM, PI_RAW_STREAM_PATH และ raw-openai-completions.jsonl ไม่ได้เป็นส่วนหนึ่งของรันไทม์หรือการทดสอบ ของ OpenClaw
• การสร้างดัชนีหน่วยความจำ QMD ต้องไม่ส่งออกบันทึกบทสนทนา SQLite ไปยังไฟล์ Markdown QMD สร้างดัชนีเฉพาะไฟล์หน่วยความจำที่กำหนดค่าไว้ ส่วนการค้นหาบันทึกบทสนทนาเซสชัน ยังคงใช้ SQLite เป็นที่จัดเก็บ
• พาธย่อยของ SDK สำหรับ QMD มีไว้สำหรับ QMD เท่านั้นในโค้ดใหม่ เครื่องมือช่วยสร้างดัชนี บันทึกบทสนทนาเซสชัน SQLite อยู่บน memory-core-host-engine-session-transcripts การส่งออกซ้ำ ผ่าน QMD ใด ๆ มีไว้เพื่อความเข้ากันได้เท่านั้นและโค้ดรันไทม์ต้องไม่ใช้
• ดัชนีหน่วยความจำในตัวอยู่ในฐานข้อมูลเอเจนต์ที่เป็นเจ้าของ การกำหนดค่ารันไทม์และ สัญญารันไทม์ที่แก้ค่าแล้วต้องไม่เปิดเผย memorySearch.store.path; doctor ลบคีย์การกำหนดค่าแบบเดิมนั้น และโค้ดปัจจุบันส่ง databasePath ของเอเจนต์ภายใน

งานติดตั้งใช้งานควรลบโค้ดต่อไปจนกว่าข้อความเหล่านี้จะเป็นจริง โดยไม่มีข้อยกเว้นนอกขอบเขต doctor/นำเข้า/ส่งออก/ดีบัก

สถานะเป้าหมายและความคืบหน้า

เป้าหมายที่เคร่งครัด

• ฐานข้อมูล SQLite ส่วนกลางหนึ่งฐานเป็นเจ้าของสถานะระนาบควบคุม: state/openclaw.sqlite
• ฐานข้อมูล SQLite หนึ่งฐานต่อเอเจนต์เป็นเจ้าของสถานะระนาบข้อมูล: agents/<agentId>/agent/openclaw-agent.sqlite
• การกำหนดค่ายังคงใช้ไฟล์เป็นที่จัดเก็บ openclaw.json ไม่ได้เป็นส่วนหนึ่งของการปรับโครงสร้าง ฐานข้อมูลนี้
• ไฟล์แบบเดิมเป็นข้อมูลนำเข้าสำหรับการย้ายข้อมูลผ่าน doctor เท่านั้น
• รันไทม์ไม่เคยเขียนหรืออ่าน JSONL ของเซสชันหรือบันทึกบทสนทนาเป็นสถานะที่ใช้งานอยู่

สถานะเป้าหมาย

• not-started: โค้ดรันไทม์ยุคไฟล์ยังคงเขียนสถานะที่ใช้งานอยู่
• migrating: โค้ด doctor/นำเข้าสามารถย้ายข้อมูลไฟล์เข้าสู่ SQLite
• dual-read: บริดจ์ชั่วคราวอ่านทั้ง SQLite และไฟล์แบบเดิม สถานะนี้ เป็นสิ่งต้องห้ามสำหรับการปรับโครงสร้างนี้ เว้นแต่จะมีการบันทึกไว้อย่างชัดเจนว่า ใช้เฉพาะกับ doctor
• sqlite-runtime: รันไทม์อ่านและเขียนเฉพาะ SQLite
• clean: API และการทดสอบรันไทม์แบบเดิมถูกลบ และตัวป้องกันขัดขวาง การถดถอย
• done: เอกสาร การทดสอบ การสำรองข้อมูล การย้ายข้อมูลผ่าน doctor และการตรวจสอบการเปลี่ยนแปลง พิสูจน์ สถานะที่สะอาด

สถานะปัจจุบัน

• เซสชัน: clean สำหรับรันไทม์ แถวเซสชันอยู่ในฐานข้อมูลต่อเอเจนต์ API รันไทม์ใช้ {agentId, sessionId} หรือ {agentId, sessionKey} และ sessions.json เป็นข้อมูลนำเข้าแบบเดิมสำหรับ doctor เท่านั้น
• บันทึกบทสนทนา: clean สำหรับรันไทม์ เหตุการณ์ อัตลักษณ์ สแนปช็อต และเหตุการณ์รันไทม์ของวิถีบันทึกบทสนทนาอยู่ในฐานข้อมูลต่อเอเจนต์ รันไทม์ไม่ รับตัวระบุตำแหน่งบันทึกบทสนทนาหรือพาธบันทึกบทสนทนา JSONL อีกต่อไป
• รันเนอร์ PI แบบฝังตัว: clean การรัน PI แบบฝังตัว เวิร์กเกอร์ที่เตรียมไว้ Compaction และลูปลองใหม่ ใช้ขอบเขตเซสชัน SQLite และปฏิเสธแฮนเดิลบันทึกบทสนทนาที่ล้าสมัย
• Cron: clean สำหรับรันไทม์ รันไทม์ใช้ cron_jobs และ task_runs ที่ Cron เป็นเจ้าของ การทดสอบรันไทม์ใช้การตั้งชื่อ storeKey ของ SQLite และพาธ Cron ยุคไฟล์ยังคงอยู่ เฉพาะในการทดสอบการย้ายข้อมูลแบบเดิมผ่าน doctor
• รีจิสทรีงาน: clean แถวรันไทม์ของงานและ Task Flow อยู่ใน state/openclaw.sqlite และตัวนำเข้า SQLite แบบไซด์คาร์ที่ยังไม่เผยแพร่ถูกลบแล้ว
• สถานะ Plugin: clean แถวสถานะ/บล็อบของ Plugin อยู่ในฐานข้อมูลส่วนกลาง ที่ใช้ร่วมกัน และมีการป้องกันไม่ให้ใช้เครื่องมือช่วย SQLite แบบไซด์คาร์ของสถานะ Plugin เก่า
• หน่วยความจำ: sqlite-runtime สำหรับหน่วยความจำในตัวและการสร้างดัชนีบันทึกบทสนทนาเซสชัน ตารางดัชนีหน่วยความจำอยู่ในฐานข้อมูลต่อเอเจนต์ สถานะหน่วยความจำของ Plugin ใช้ แถวสถานะ Plugin ที่ใช้ร่วมกัน และไฟล์หน่วยความจำแบบเดิมเป็นข้อมูลนำเข้าสำหรับการย้ายผ่าน doctor หรือเนื้อหาในพื้นที่ทำงานของผู้ใช้
• การสำรองข้อมูล: sqlite-runtime การสำรองข้อมูลจัดเตรียมสแนปช็อต SQLite แบบกระชับ ละเว้นไซด์คาร์ WAL/SHM ที่กำลังใช้งาน ตรวจสอบความสมบูรณ์ของ SQLite และบันทึกการรันสำรองข้อมูลใน ฐานข้อมูลส่วนกลาง
• การตั้งค่าพื้นที่ทำงาน: sqlite-runtime การตั้งค่าเสร็จสมบูรณ์ การรับรองพื้นที่ทำงาน และแฮชบูตสแตรปที่สร้างขึ้นอยู่ในตาราง SQLite ที่ใช้ร่วมกันและมีชนิดกำกับ รันไทม์ ไม่อ่านหรือเขียน JSON ของพื้นที่ทำงานที่เลิกใช้แล้วและไซด์คาร์ .attested; Doctor เป็นเจ้าของการนำเข้าที่ผ่านการตรวจสอบและการลบที่ผ่านการยืนยัน
• การย้ายข้อมูลผ่าน Doctor: migrating โดยเจตนา Doctor นำเข้า JSON JSONL และที่จัดเก็บแบบไซด์คาร์ที่เลิกใช้แล้วเข้าสู่ SQLite บันทึกการรัน/แหล่งที่มาของการย้ายข้อมูล และลบแหล่งที่มาที่ดำเนินการสำเร็จ
• การอนุมัติ Exec: file-runtime TypeScript และ macOS ยังคงอ่านและเขียน exec-approvals.json ของไดเรกทอรีสถานะที่ใช้งานอยู่ ส่วนสคีมา exec_approvals_config ที่สงวนไว้ยังไม่มีเจ้าของรันไทม์ การเปลี่ยนผ่านในอนาคตต้อง เพิ่มการนำเข้าผ่าน doctor ในสถานะเดียวกันและย้ายรันไทม์ทั้งสองพร้อมกัน
• สคริปต์ E2E: clean สำหรับความครอบคลุมรันไทม์ การเตรียมข้อมูล Docker MCP เขียนแถว SQLite สคริปต์ Docker สำหรับบริบทรันไทม์สร้าง JSONL แบบเดิมเฉพาะภายใน ข้อมูลเริ่มต้นสำหรับการย้ายผ่าน doctor และระบุชื่อพาธดัชนีเซสชันแบบเดิมไว้อย่างชัดเจน

งานที่เหลือ

• [x] เปลี่ยนชื่อตัวแปรที่จัดเก็บในการทดสอบรันไทม์ Cron ไม่ให้ใช้ storePath เว้นแต่ จะเป็นข้อมูลนำเข้าแบบเดิมสำหรับ doctor ไฟล์: src/cron/service.test-harness.ts, src/cron/service.runs-one-shot-main-job-disables-it.test.ts, src/cron/service/timer.regression.test.ts, src/cron/service/ops.test.ts, src/cron/service/store.test.ts, src/cron/service.heartbeat-ok-summary-suppressed.test.ts, src/cron/service.main-job-passes-heartbeat-target-last.test.ts, src/cron/store.test.ts หลักฐาน: pnpm check:database-first-legacy-stores; rg -n 'storePath' src/cron --glob '!**/commands/doctor/**'
• [x] ลบหรือเปลี่ยนชื่อม็อกการทดสอบการส่งออกยุคไฟล์ที่ล้าสมัย ไฟล์: src/auto-reply/reply/commands-export-test-mocks.ts หลักฐาน: rg -n 'resolveSessionFilePath|sessionFile|storePath|transcriptLocator' src/auto-reply/reply
• [x] ทำให้ข้อมูลเริ่มต้น JSONL แบบเดิมของบริบทรันไทม์ Docker เห็นได้ชัดว่าใช้เฉพาะกับ doctor ไฟล์: scripts/e2e/session-runtime-context-docker-client.ts หลักฐาน: rg -n 'sessions\\.json|sessionFile|\\.jsonl' scripts/e2e/session-runtime-context-docker-client.ts แสดงเฉพาะ seedBrokenLegacySessionForDoctorMigration
• [x] รักษาชนิดที่ Kysely สร้างให้สอดคล้องหลังการเปลี่ยนแปลงสคีมาใด ๆ ไฟล์: src/state/openclaw-state-schema.sql, src/state/openclaw-agent-schema.sql, src/state/*generated* หลักฐาน: ไม่มีการเปลี่ยนแปลงสคีมาในรอบนี้; pnpm db:kysely:check; pnpm lint:kysely
• [x] รันการทดสอบแบบเจาะจงอีกครั้งสำหรับที่จัดเก็บ คำสั่ง และสคริปต์ที่แก้ไข หลักฐาน: pnpm test src/cron/service/store.test.ts src/cron/store.test.ts src/cron/service.heartbeat-ok-summary-suppressed.test.ts src/cron/service.main-job-passes-heartbeat-target-last.test.ts src/cron/service.every-jobs-fire.test.ts src/cron/service.persists-delivered-status.test.ts src/cron/service.runs-one-shot-main-job-disables-it.test.ts src/cron/service/ops.test.ts src/cron/service/timer.regression.test.ts src/auto-reply/reply/commands-export-session.test.ts extensions/telegram/src/thread-bindings.test.ts extensions/slack/src/monitor/message-handler/prepare.test.ts src/acp/translator.session-lineage-meta.test.ts; git diff --check
• [x] ก่อนประกาศ done ให้รันเกตการเปลี่ยนแปลงหรือการพิสูจน์แบบกว้างจากระยะไกล หลักฐาน: pnpm check:changed --timed -- <changed extension paths> ผ่านบน การรัน Hetzner Crabbox run_3f1cabf6b25c หลังตั้งค่า Node 24/pnpm ชั่วคราวและ กำหนดเส้นทางพาธอย่างชัดเจนสำหรับพื้นที่ทำงานที่ซิงค์แล้วซึ่งไม่มี .git

ห้ามถดถอย

• ห้ามมีตัวระบุตำแหน่งบันทึกบทสนทนา
• ห้ามมีไฟล์เซสชันที่ใช้งานอยู่
• ห้ามมีฟิกซ์เจอร์ทดสอบ JSONL ปลอม ยกเว้นการทดสอบการย้ายข้อมูลแบบเดิมผ่าน doctor
• ห้ามเข้าถึง SQLite แบบดิบในจุดที่คาดให้ใช้ Kysely
• ห้ามมีการย้ายฐานข้อมูลยุคไฟล์ใหม่ สคีมาส่วนกลางยังคงอยู่ที่เวอร์ชัน 1 สคีมาเวอร์ชัน 1 ต่อเอเจนต์ที่เผยแพร่แล้วมีการย้ายรันไทม์แบบจำกัดหนึ่งรายการไปยัง เวอร์ชัน 2 เพื่อให้อัตลักษณ์แหล่งที่มาของหน่วยความจำมีเสถียรภาพ

สมมติฐานจากการอ่านโค้ด

ไม่มีข้อสรุปด้านผลิตภัณฑ์เพิ่มเติมที่ขัดขวางแผนนี้ การติดตั้งใช้งานควร ดำเนินต่อไปภายใต้สมมติฐานต่อไปนี้:

• ใช้ node:sqlite โดยตรง และกำหนดให้เส้นทางการจัดเก็บนี้ใช้รันไทม์ Node ที่ปลอดภัยต่อการรีเซ็ต WAL (22.22.3+, 24.15+ หรือ 25.9+)
• เก็บไฟล์การกำหนดค่าปกติไว้เพียงไฟล์เดียวเท่านั้น อย่าย้ายการกำหนดค่า manifest ของ Plugin หรือพื้นที่ทำงาน Git ไปไว้ใน SQLite ในการปรับโครงสร้างครั้งนี้
• ไม่จำเป็นต้องมีไฟล์สำหรับความเข้ากันได้ของรันไทม์ ไฟล์ JSON และ JSONL แบบเดิมเป็นเพียง อินพุตสำหรับการย้ายข้อมูลเท่านั้น ไฟล์ sidecar ของ SQLite ที่มีเฉพาะในสาขานี้ไม่เคยเผยแพร่ จึงถูกลบแทนที่จะนำเข้า
• openclaw doctor --fix เป็นเจ้าของการย้ายข้อมูลจากไฟล์แบบเดิมไปยังฐานข้อมูล การเริ่มต้น รันไทม์เป็นเจ้าของเฉพาะการอัปเกรดแบบมีขอบเขตระหว่างเวอร์ชันสคีมา SQLite ที่เผยแพร่แล้ว และต้องไม่นำเข้าสถานะจากยุคที่ใช้ไฟล์
• ความเข้ากันได้ของข้อมูลประจำตัวใช้กฎเดียวกัน กล่าวคือข้อมูลประจำตัวของรันไทม์อยู่ใน SQLite ไฟล์ auth-profiles.json แบบเก่า, auth.json ประจำเอเจนต์ และ credentials/oauth.json ที่ใช้ร่วมกันเป็นอินพุตสำหรับการย้ายข้อมูลของ doctor จากนั้นจะถูกลบ หลังนำเข้า
• สถานะแค็ตตาล็อกโมเดลที่สร้างขึ้นมีฐานข้อมูลรองรับ โค้ดรันไทม์ต้องไม่เขียน agents/<agentId>/agent/models.json; ไฟล์ models.json ที่มีอยู่เป็นอินพุตแบบเดิม สำหรับ doctor และจะถูกลบหลังนำเข้าไปยัง agent_model_catalogs
• รันไทม์ต้องไม่ย้ายข้อมูล ปรับให้อยู่ในรูปแบบมาตรฐาน หรือเชื่อมตัวระบุตำแหน่งทรานสคริปต์ ข้อมูลระบุตัวตนของทรานสคริปต์ที่ใช้งานอยู่คือ {agentId, sessionId} ใน SQLite พาธไฟล์เป็นเพียง อินพุตแบบเดิมสำหรับ doctor และ sqlite-transcript://... ต้องหายไปจาก พื้นผิวของรันไทม์ โปรโตคอล hook และ Plugin แทนที่จะถูกใช้เป็น ตัวจัดการขอบเขต
• การอ่านทรานสคริปต์ SQLite ของรันไทม์จะไม่เรียกใช้การย้ายรูปแบบรายการ JSONL แบบเก่า หรือเขียนทรานสคริปต์ทั้งหมดใหม่เพื่อความเข้ากันได้ การปรับรายการแบบเดิมให้อยู่ในรูปแบบมาตรฐานยังคงอยู่ใน ยูทิลิตี doctor/นำเข้าที่เรียกใช้อย่างชัดเจน Doctor จะปรับไฟล์ทรานสคริปต์ JSONL แบบเดิม ให้อยู่ในรูปแบบมาตรฐานก่อนแทรกแถว SQLite ส่วนแถวรันไทม์ปัจจุบัน ถูกเขียนด้วยสคีมาทรานสคริปต์ปัจจุบันอยู่แล้ว การส่งออกเส้นทางการทำงาน/เซสชัน จะอ่านแถวเหล่านั้นตามที่เป็น และต้องไม่ดำเนินการย้ายข้อมูลแบบเดิมในขณะส่งออก
• ตัวช่วยแยกวิเคราะห์/ย้ายข้อมูล JSONL ของทรานสคริปต์แบบเดิมมีไว้สำหรับ doctor เท่านั้น โค้ดรูปแบบ ทรานสคริปต์ของรันไทม์สร้างเฉพาะบริบททรานสคริปต์ SQLite ปัจจุบัน ส่วน doctor เป็นเจ้าของการอัปเกรดรายการ JSONL แบบเก่าก่อนแทรกแถว
• ตัวช่วยสตรีมทรานสคริปต์ JSONL แบบเก่าที่รันไทม์เป็นเจ้าของถูกลบแล้ว โค้ดนำเข้า ของ doctor เป็นเจ้าของการอ่านไฟล์แบบเดิมอย่างชัดเจน ส่วนประวัติเซสชันของรันไทม์อ่าน แถว SQLite
• การเชื่อมโยง app-server ของ Codex ใช้ sessionId ของ OpenClaw เป็นคีย์มาตรฐาน ในเนมสเปซสถานะ Plugin ของ Codex ส่วน sessionKey เป็นเมทาดาทาสำหรับ การกำหนดเส้นทาง/การแสดงผล และต้องไม่แทนที่รหัสเซสชันถาวรหรือทำให้ ข้อมูลระบุตัวตนจากไฟล์ทรานสคริปต์กลับมาอีก
• กลไกบริบทจะได้รับสัญญารันไทม์ปัจจุบันโดยตรง รีจิสทรี ต้องไม่ห่อหุ้มกลไกด้วย shim สำหรับลองใหม่ที่ลบ sessionKey, transcriptScope หรือ prompt; กลไกที่ไม่สามารถรับพารามิเตอร์แบบ ฐานข้อมูลมาก่อนในปัจจุบันควรล้มเหลวอย่างชัดเจนแทนที่จะถูกเชื่อมต่อผ่านตัวกลาง
• เอาต์พุตการสำรองข้อมูลควรคงเป็นไฟล์เก็บถาวรหนึ่งไฟล์ เนื้อหาฐานข้อมูลควรถูกบรรจุ ลงในไฟล์เก็บถาวรนั้นเป็นสแนปช็อต SQLite แบบกะทัดรัด ไม่ใช่ไฟล์ sidecar ของ WAL ที่กำลังใช้งานแบบดิบ
• การค้นหาทรานสคริปต์มีประโยชน์ แต่ไม่จำเป็นสำหรับการปรับใช้แบบฐานข้อมูลมาก่อน ครั้งแรก ออกแบบสคีมาให้สามารถเพิ่ม FTS ได้ภายหลัง
• การดำเนินงานของ worker ควรยังคงเป็นฟีเจอร์ทดลองภายใต้การตั้งค่า ขณะที่ขอบเขต ฐานข้อมูลเริ่มลงตัว

ข้อค้นพบจากการอ่านโค้ด

สาขาปัจจุบันผ่านขั้นพิสูจน์แนวคิดมาแล้ว มีฐานข้อมูล ที่ใช้ร่วมกันอยู่แล้ว, Node node:sqlite เชื่อมต่อผ่านตัวช่วยรันไทม์ขนาดเล็ก และ พื้นที่จัดเก็บเดิมขณะนี้เขียนไปยัง state/openclaw.sqlite หรือฐานข้อมูล openclaw-agent.sqlite ของเจ้าของ

งานที่เหลือไม่ใช่การเลือก SQLite แต่คือการรักษาขอบเขตใหม่ให้สะอาด และลบอินเทอร์เฟซที่สร้างขึ้นเพื่อความเข้ากันได้ทั้งหมดซึ่งยังดูคล้ายโลกแบบใช้ไฟล์เดิม:

• เซสชัน storePath ไม่ใช่ข้อมูลระบุตัวตนของรันไทม์ รูปแบบ fixture สำหรับการทดสอบ หรือ ฟิลด์เพย์โหลดสถานะอีกต่อไป การทดสอบรันไทม์และบริดจ์ไม่มีชื่อสัญญา storePath แล้ว โดยโค้ด doctor/การย้ายข้อมูลเป็นเจ้าของคำศัพท์แบบเดิมนั้น
• การเขียนเซสชันไม่ผ่านคิว store-writer.ts ภายในโพรเซสแบบเก่า อีกต่อไป การเขียนแพตช์ SQLite จะเตรียมข้อมูลนอกธุรกรรม จากนั้นใช้ธุรกรรม ตรวจสอบ/นำไปใช้แบบซิงโครนัสที่สั้น พร้อมการตรวจหาข้อขัดแย้งอย่างชัดเจน
• การค้นหาพาธแบบเดิมยังมีกรณีใช้งานที่ถูกต้องสำหรับการย้ายข้อมูล แต่โค้ดรันไทม์ควร หยุดถือว่า sessions.json และไฟล์ทรานสคริปต์ JSONL เป็นเป้าหมายการเขียนที่เป็นไปได้
• ตารางที่เอเจนต์เป็นเจ้าของอยู่ในฐานข้อมูล SQLite ประจำเอเจนต์ ฐานข้อมูลส่วนกลางเก็บ แถวรีจิสทรี/ระนาบควบคุม ส่วนข้อมูลระบุตัวตนของทรานสคริปต์คือ {agentId, sessionId} ใน แถวทรานสคริปต์ประจำเอเจนต์ โค้ดรันไทม์ต้องไม่จัดเก็บพาธไฟล์ทรานสคริปต์ อย่างถาวรหรือย้ายตัวระบุตำแหน่งทรานสคริปต์
• Doctor นำเข้าไฟล์แบบเดิมหลายไฟล์อยู่แล้ว การเก็บกวาดคือทำให้กระบวนการนั้นเป็น การใช้งานการย้ายข้อมูลที่ชัดเจนเพียงชุดเดียวซึ่ง doctor เรียกใช้ พร้อมรายงาน การย้ายข้อมูลแบบถาวร

ไม่มีคำถามเพิ่มเติมเกี่ยวกับผลิตภัณฑ์ที่ขัดขวางการนำไปใช้

รูปแบบโค้ดปัจจุบัน

สาขานี้มีฐาน SQLite ที่ใช้ร่วมกันจริงอยู่แล้ว:

• ขณะนี้เวอร์ชันขั้นต่ำของรันไทม์ต้องเป็นบิลด์ Node ที่รีเซ็ต WAL ได้อย่างปลอดภัย: 22.22.3+, 24.15+ หรือ 25.9+ โดย package.json, ตัวป้องกันรันไทม์ของ CLI, ค่าเริ่มต้นของตัวติดตั้ง, ตัวระบุตำแหน่งรันไทม์ของ macOS, CI และเอกสารการติดตั้งสาธารณะต่างกำหนดตรงกัน
• src/state/openclaw-state-db.ts เปิด openclaw.sqlite, ตั้งค่า WAL, synchronous=NORMAL, busy_timeout=30000, foreign_keys=ON และใช้ โมดูลสคีมาที่สร้างขึ้นจาก src/state/openclaw-state-schema.sql
• ประเภทตาราง Kysely และโมดูลสคีมารันไทม์สร้างขึ้นจากฐานข้อมูล SQLite แบบใช้แล้วทิ้งซึ่งสร้างจากไฟล์ .sql ที่คอมมิตไว้ โค้ดรันไทม์ไม่ เก็บสตริงสคีมาที่คัดลอกและวางไว้สำหรับฐานข้อมูลส่วนกลาง ฐานข้อมูลต่อเอเจนต์ หรือฐานข้อมูล บันทึกพร็อกซีอีกต่อไป
• ที่เก็บรันไทม์อนุมานประเภทแถวที่เลือกและแทรกจากอินเทอร์เฟซ Kysely DB ที่สร้างขึ้นเหล่านั้น แทนการกำหนดรูปร่างแถว SQLite ซ้ำด้วยตนเอง ส่วน SQL ดิบ ยังคงจำกัดไว้เฉพาะการใช้สคีมา pragma และ DDL สำหรับการย้ายข้อมูลเท่านั้น
• สคีมา SQLite ส่วนกลางยังคงอยู่ที่ user_version = 1 สคีมาต่อเอเจนต์ อยู่ที่เวอร์ชัน 2 โดยตัวเปิดจะย้ายคีย์แหล่งหน่วยความจำของเวอร์ชัน 1 ที่เผยแพร่แล้วไปเป็นอัตลักษณ์จำนวนเต็มที่เสถียรแบบอะตอม การนำเข้าจากไฟล์ไปยังฐานข้อมูล ยังคงอยู่ในโค้ด doctor
• มีการบังคับใช้ความเป็นเจ้าของเชิงสัมพันธ์ในจุดที่ขอบเขตความเป็นเจ้าของเป็นแหล่งมาตรฐาน: แถวการย้ายแหล่งข้อมูลลบต่อเนื่องจาก migration_runs, สถานะการส่งมอบงาน ลบต่อเนื่องจาก task_runs และแถวอัตลักษณ์ทรานสคริปต์ลบต่อเนื่องจาก เหตุการณ์ทรานสคริปต์
• ตารางที่ใช้ร่วมกันในปัจจุบันประกอบด้วย agent_databases, auth_profile_stores, auth_profile_state, plugin_state_entries, plugin_blob_entries, media_blobs, skill_uploads, capture_sessions, capture_events, capture_blobs, sandbox_registry_entries, cron_jobs, commitments, delivery_queue_entries, model_capability_cache, workspace_setup_state, workspace_path_aliases, workspace_attestations, workspace_generated_bootstrap_hashes, native_hook_relay_bridges, current_conversation_bindings, plugin_binding_approvals, tui_last_sessions, acp_sessions, acp_replay_sessions, acp_replay_events, task_runs, task_delivery_state, flow_runs, subagent_runs, migration_runs และ backup_runs
• สถานะตามอำเภอใจที่ Plugin เป็นเจ้าของจะไม่ได้รับตารางแบบมีประเภทซึ่งโฮสต์เป็นเจ้าของ Plugin ที่ติดตั้งใช้ plugin_state_entries สำหรับเพย์โหลด JSON ที่มีเวอร์ชัน และ plugin_blob_entries สำหรับข้อมูลไบต์ พร้อมความเป็นเจ้าของเนมสเปซ/คีย์ การล้างข้อมูลตาม TTL การสำรองข้อมูล และระเบียนการย้ายข้อมูลของ Plugin สถานะการประสานงาน Plugin ที่โฮสต์เป็นเจ้าของยังคง มีตารางแบบมีประเภทได้เมื่อโฮสต์เป็นเจ้าของสัญญาการสืบค้น เช่น plugin_binding_approvals
• การย้ายข้อมูลของ Plugin เป็นการย้ายข้อมูลเหนือเนมสเปซที่ Plugin เป็นเจ้าของ ไม่ใช่การย้าย สคีมาของโฮสต์ Plugin สามารถย้ายรายการสถานะ/บล็อบที่มีเวอร์ชันของตนเอง ผ่านผู้ให้บริการการย้ายข้อมูล และโฮสต์จะบันทึกสถานะแหล่งที่มา/การทำงานไว้ใน บัญชีแยกประเภทการย้ายข้อมูลตามปกติ การติดตั้ง Plugin ใหม่ไม่จำเป็นต้องเปลี่ยน openclaw-state-schema.sql เว้นแต่โฮสต์จะเข้ารับความเป็นเจ้าของ สัญญาข้าม Plugin ใหม่ด้วยตนเอง
• src/state/openclaw-agent-db.ts เปิด agents/<agentId>/agent/openclaw-agent.sqlite, ลงทะเบียนฐานข้อมูลใน DB ส่วนกลาง และเป็นเจ้าของตารางเซสชัน ทรานสคริปต์ VFS อาร์ติแฟกต์ แคช และดัชนีหน่วยความจำภายในเอเจนต์ ขณะนี้การค้นหารันไทม์ที่ใช้ร่วมกันอ่านรีจิสทรี agent_databases แบบมีประเภทที่สร้างขึ้น แทนการสร้างการสืบค้นนั้นใหม่ในแต่ละ จุดเรียกใช้
• ฐานข้อมูลส่วนกลางและต่อเอเจนต์บันทึกแถว schema_meta ซึ่งมีบทบาทของฐานข้อมูล เวอร์ชันสคีมา การประทับเวลา และ ID เอเจนต์สำหรับฐานข้อมูลเอเจนต์ DB ส่วนกลาง ยังคงอยู่ที่ user_version = 1 ส่วน DB ต่อเอเจนต์ใช้เวอร์ชัน 2 หลังจากการย้าย อัตลักษณ์แหล่งหน่วยความจำแบบมีขอบเขต
• ขณะนี้อัตลักษณ์เซสชันต่อเอเจนต์มีตารางรากมาตรฐาน sessions ซึ่งใช้ session_id เป็นคีย์ โดยมี session_key, session_scope, account_id, primary_conversation_id, การประทับเวลา ฟิลด์แสดงผล เมทาดาทาของโมเดล, ID ฮาร์เนส และการเชื่อมโยงพาเรนต์/การสร้างเป็นคอลัมน์ที่สืบค้นได้ session_routes เป็นดัชนีเส้นทางที่ใช้งานอยู่แบบไม่ซ้ำจาก session_key ไปยัง session_id ปัจจุบัน เพื่อให้คีย์เส้นทางย้ายไปยังเซสชันถาวรใหม่ได้โดยไม่ ทำให้การอ่านในเส้นทางด่วนต้องเลือกระหว่างแถว sessions.session_key ที่ซ้ำกัน เพย์โหลดเก่า session_entries.entry_json ที่มีรูปร่างเพื่อความเข้ากันได้เชื่อมอยู่กับ รากถาวร session_id ผ่านคีย์นอก และไม่ได้เป็นเพียง ตัวแทนระดับสคีมาแบบเดียวของเซสชันอีกต่อไป
• อัตลักษณ์การสนทนาภายนอกต่อเอเจนต์เป็นเชิงสัมพันธ์ด้วยเช่นกัน: conversations เก็บอัตลักษณ์ผู้ให้บริการ/บัญชี/การสนทนาที่ทำให้เป็นมาตรฐาน และ session_conversations เชื่อมเซสชัน OpenClaw หนึ่งเซสชันกับการสนทนาภายนอกหนึ่งรายการขึ้นไป ซึ่งรองรับเซสชัน DM แบบ main ที่ใช้ร่วมกัน ซึ่งเพียร์หลายรายสามารถแมปไปยังเซสชันเดียวโดยตั้งใจ ได้โดยไม่บันทึกข้อมูลเท็จใน session_key นอกจากนี้ SQLite ยัง บังคับใช้ความไม่ซ้ำกันสำหรับอัตลักษณ์ผู้ให้บริการตามธรรมชาติ เพื่อไม่ให้ทูเพิล ช่องทาง/บัญชี/ชนิด/เพียร์/เธรดเดียวกันแยกไปยัง ID การสนทนาหลายรายการได้ เพียร์โดยตรงของ main ที่ใช้ร่วมกันเชื่อมด้วยบทบาท participant เพื่อให้ เซสชัน OpenClaw หนึ่งเซสชันสามารถแทนเพียร์ DM ภายนอกหลายรายได้โดยไม่ลดสถานะ เพียร์เก่าให้เป็นเพียงแถวที่เกี่ยวข้องอย่างคลุมเครือ sessions.primary_conversation_id ยังคง ชี้ไปยังเป้าหมายการส่งมอบแบบมีประเภทปัจจุบัน คอลัมน์การกำหนดเส้นทาง/สถานะที่เป็นชุดปิด ถูกบังคับใช้ด้วยข้อจำกัด CHECK ของ SQLite แทนการพึ่งพา ยูเนียน TypeScript เพียงอย่างเดียว การฉายเซสชันรันไทม์จะล้างเงาการกำหนดเส้นทางเพื่อความเข้ากันได้ออกจาก session_entries.entry_json ก่อนใช้คอลัมน์เซสชัน/การสนทนาแบบมีประเภท เพื่อไม่ให้เพย์โหลด JSON ที่ล้าสมัยทำให้เป้าหมายการส่งมอบกลับมาปรากฏอีก การกำหนดเส้นทางประกาศของเอเจนต์ย่อยก็ต้องใช้บริบทการส่งมอบ SQLite แบบมีประเภทเช่นกัน และจะไม่ย้อนกลับไปใช้ฟิลด์เส้นทาง SessionEntry เพื่อความเข้ากันได้อีกต่อไป การสืบทอดการส่งมอบแบบชัดแจ้งของ Gateway chat.send อ่านบริบทการส่งมอบ SQLite แบบมีประเภทแทนฟิลด์เพื่อความเข้ากันได้ origin/last* tools.effective อนุมานบริบทผู้ให้บริการ/บัญชี/เธรดจากแถว การส่งมอบ/การกำหนดเส้นทาง SQLite แบบมีประเภทเช่นกัน ไม่ใช่เงารายการเซสชัน last* ที่ล้าสมัย บริบทพรอมต์ของเหตุการณ์ระบบสร้างฟิลด์ช่องทาง/ปลายทาง/บัญชี/เธรดใหม่จาก ฟิลด์การส่งมอบแบบมีประเภท แทนเงา origin ขณะนี้ตัวช่วย deliveryContextFromSession ที่ใช้ร่วมกันและตัวแมปเซสชันไปยังการสนทนา จะละเว้น SessionEntry.origin โดยสิ้นเชิง มีเพียงฟิลด์การส่งมอบแบบมีประเภท และแถวการสนทนาเชิงสัมพันธ์เท่านั้นที่สร้างอัตลักษณ์เส้นทางด่วนได้ การปรับรายการเซสชันรันไทม์ให้เป็นมาตรฐานจะตัด origin ออกก่อนบันทึกหรือ ฉาย entry_json และการเขียนเมทาดาทาขาเข้าจะเขียนฟิลด์ช่องทาง/แชต แบบมีประเภทพร้อมแถวการสนทนาเชิงสัมพันธ์ แทนการสร้างเงาต้นทางใหม่
• ขณะนี้เหตุการณ์ทรานสคริปต์ สแนปช็อตทรานสคริปต์ และเหตุการณ์รันไทม์ของวิถี อ้างอิงรากมาตรฐานต่อเอเจนต์ sessions และลบต่อเนื่องเมื่อเซสชัน ถูกลบ แถวอัตลักษณ์/การทำซ้ำได้อย่างปลอดภัยของทรานสคริปต์ยังคงลบต่อเนื่องจาก แถวเหตุการณ์ทรานสคริปต์ที่ตรงกัน
• ขณะนี้ดัชนี memory-core ใช้ตารางฐานข้อมูลเอเจนต์ที่ระบุอย่างชัดเจน memory_index_meta, memory_index_sources, memory_index_chunks และ memory_embedding_cache โดย memory_index_state ติดตามการเปลี่ยนแปลงรีวิชัน ดัชนีข้างเคียง FTS/เวกเตอร์แบบไม่บังคับใช้ชื่อ memory_index_chunks_fts และ memory_index_chunks_vec แทนตารางชื่อทั่วไป meta, files, chunks, chunks_fts หรือ chunks_vec ชื่อมาตรฐานยังคงรักษารูปร่างแถว พาธ/แหล่งข้อมูลปัจจุบันและความเข้ากันได้ของเอ็มเบดดิงแบบซีเรียลไลซ์ ตารางเหล่านี้ เป็นแคชที่ได้มาสำหรับการค้นหา ไม่ใช่ที่เก็บทรานสคริปต์มาตรฐาน จึงสามารถ ลบและสร้างใหม่จากไฟล์เวิร์กสเปซหน่วยความจำและแหล่งข้อมูลที่กำหนดค่าไว้ได้ การเปิดดัชนีหน่วยความจำชื่อทั่วไปที่เผยแพร่แล้วจะย้ายเมทาดาทา แหล่งข้อมูล ชังก์ และแคชเอ็มเบดดิงไปยังตารางมาตรฐาน ส่วนตาราง FTS/เวกเตอร์ ที่ได้มาจะถูกสร้างใหม่ภายใต้ชื่อมาตรฐาน
• ขณะนี้สถานะการกู้คืนการทำงานของเอเจนต์ย่อยอยู่ในแถว subagent_runs แบบมีประเภทที่ใช้ร่วมกัน พร้อมคีย์เซสชันลูก ผู้ร้องขอ และตัวควบคุมที่มีดัชนี ไฟล์เก่า subagents/runs.json เป็นเพียงอินพุตสำหรับการล้างข้อมูลของ Doctor รายการการทำงานในไฟล์ เป็นสถานะการกู้คืนชั่วคราว ดังนั้น Doctor จะบันทึกหลักฐานการเลิกใช้งานและ ทิ้งไฟล์โดยไม่นำเข้า เนื่องจากไฟล์ไม่สามารถพิสูจน์ได้ว่ารายการ ยังทำงานอยู่หรือล้าสมัยหลังจากแถว SQLite ถูกตัดออกแล้ว ผู้ดูแลระบบ ต้องปล่อยให้การทำงานที่ยังใช้งานอยู่จากยุคไฟล์เสร็จสิ้นก่อนอัปเกรดข้ามขอบเขตนี้
• ขณะนี้การผูกการสนทนาปัจจุบันอยู่ในแถวแบบมีประเภทที่ใช้ร่วมกัน current_conversation_bindings ซึ่งใช้ ID การสนทนาที่ทำให้เป็นมาตรฐานเป็นคีย์ โดยมี คอลัมน์เอเจนต์/เซสชันเป้าหมาย ชนิดการสนทนา สถานะ เวลาหมดอายุ และเมทาดาทา เก็บเป็นคอลัมน์เชิงสัมพันธ์ แทนระเบียนการผูกแบบทึบแสงที่ซ้ำกัน คีย์การผูกแบบถาวรรวมชนิดการสนทนาที่ทำให้เป็นมาตรฐาน เพื่อให้ การอ้างอิงแบบโดยตรง/กลุ่ม/ช่องทางไม่ชนกัน และ SQLite จะปฏิเสธค่าชนิด/สถานะ การผูกที่ไม่ถูกต้อง ไฟล์เก่า bindings/current-conversations.json เป็นเพียงอินพุตการย้ายข้อมูลของ doctor
• ขณะนี้การกู้คืนคิวการส่งมอบซ้อนทับคอลัมน์คิวแบบมีประเภทสำหรับช่องทาง เป้าหมาย บัญชี เซสชัน การลองใหม่ ข้อผิดพลาด การส่งผ่านแพลตฟอร์ม และสถานะการกู้คืนลงบน JSON สำหรับเล่นซ้ำ entry_json ยังคงเก็บเพย์โหลดสำหรับเล่นซ้ำ ฮุก และเพย์โหลด การจัดรูปแบบ แต่คอลัมน์แบบมีประเภทเป็นแหล่งข้อมูลที่มีอำนาจสำหรับการกำหนดเส้นทาง/สถานะคิวด่วน
• ขณะนี้ตัวชี้การคืนค่าเซสชันล่าสุดของ TUI อยู่ในแถวแบบมีประเภทที่ใช้ร่วมกัน tui_last_sessions ซึ่งใช้ขอบเขตการเชื่อมต่อ/เซสชัน TUI ที่แฮชแล้วเป็นคีย์ รันไทม์อ่านและเขียนเฉพาะ SQLite, อัปเซิร์ตแต่ละขอบเขตแบบอะตอม และ ไม่รวมเซสชัน Heartbeat openclaw doctor --fix ตรวจสอบความถูกต้องของ ไฟล์ JSON เก่าของ TUI อย่างเคร่งครัด เก็บแถว SQLite ที่ใหม่กว่า ตรวจสอบผลลัพธ์มาตรฐาน และลบไฟล์เดิมที่ไม่เปลี่ยนแปลง แทนการเก็บไฟล์ถาวรไว้
• ขณะนี้แฮชการปรับใช้คำสั่ง Discord อยู่ในที่เก็บ SQLite สำหรับสถานะ Plugin ที่ใช้ร่วมกัน รันไทม์อ่านและเขียนเฉพาะคีย์ที่กำหนดขอบเขตตามแอปพลิเคชันอย่างแม่นยำ Doctor ลบไฟล์เดิม discord/command-deploy-cache.json ที่สร้างใหม่ได้ โดยไม่นำเข้า ดังนั้นการเริ่มต้นครั้งถัดไปจะดำเนินการกระทบยอดตามมาตรฐานหนึ่งครั้ง
• ขณะนี้ค่ากำหนด TTS เริ่มต้นอยู่ในแถว SQLite สำหรับสถานะ Plugin ที่ใช้ร่วมกัน ซึ่งใช้คีย์ภายใต้ Plugin speech-core ไฟล์เก่า settings/tts.json เป็นเพียงอินพุต การย้ายข้อมูลของ doctor รันไทม์ไม่อ่านหรือเขียนไฟล์ JSON ค่ากำหนด TTS อีกต่อไป และ ตัวแก้พาธเดิมอยู่ในโมดูลการย้ายข้อมูลของ doctor
• ขณะนี้เมทาดาทาเป้าหมายข้อมูลลับกล่าวถึงที่เก็บ แทนการทำเสมือนว่า เป้าหมายข้อมูลประจำตัวทุกแห่งเป็นไฟล์กำหนดค่า openclaw.json ยังคงเป็นที่เก็บการกำหนดค่า ส่วนเป้าหมายโปรไฟล์การรับรองความถูกต้องใช้แถว SQLite แบบมีประเภท auth_profile_stores โดยเก็บ ข้อมูลประจำตัวตามรูปแบบของผู้ให้บริการเป็นเพย์โหลด JSON
• การตรวจสอบข้อมูลลับจะไม่สแกนไฟล์ต่อเอเจนต์ auth.json ที่เลิกใช้แล้วอีกต่อไป Doctor เป็นผู้รับผิดชอบ การเตือน การนำเข้า และการลบไฟล์เดิมดังกล่าว
• ขณะนี้ตัวช่วยพาธโปรไฟล์การรับรองความถูกต้องแบบเดิมอยู่ในโค้ดเดิมของ doctor ตัวช่วยพาธ โปรไฟล์การรับรองความถูกต้องหลักจะแสดงอัตลักษณ์ที่เก็บการรับรองความถูกต้อง SQLite และตำแหน่งแสดงผล ไม่ใช่พาธรันไทม์ auth-profiles.json หรือ auth-state.json
• ขณะนี้โมดูลรันไทม์สำหรับการกู้คืนการทำงานของเอเจนต์ย่อยและแคชความสามารถของโมเดล OpenRouter แยกตัวอ่าน/เขียนสแนปช็อต SQLite ออกจากตัวช่วยนำเข้า JSON เดิมที่ใช้เฉพาะใน doctor ความสามารถ OpenRouter ใช้แถวทั่วไปแบบมีประเภท model_capability_cache ภายใต้ provider_id = "openrouter" แทน บล็อบแคชทึบแสงก้อนเดียวหรือตารางโฮสต์เฉพาะผู้ให้บริการ การทำงานของเอเจนต์ย่อย taskName ถูกเก็บในคอลัมน์แบบมีประเภท subagent_runs.task_name ส่วนสำเนา payload_json เป็นข้อมูลสำหรับเล่นซ้ำ/ดีบัก ไม่ใช่แหล่งข้อมูลสำหรับฟิลด์แสดงผลหรือ ค้นหาในเส้นทางด่วน
• src/agents/filesystem/virtual-agent-fs.sqlite.ts ใช้งาน VFS ของ SQLite เหนือตาราง vfs_entries ในฐานข้อมูลเอเจนต์ การอ่านไดเรกทอรี การส่งออก แบบเรียกซ้ำ การลบ และการเปลี่ยนชื่อใช้ช่วงคำนำหน้า (namespace, path) ที่มีดัชนี แทนการสแกนทั้งเนมสเปซหรือพึ่งพาการจับคู่พาธ LIKE
• src/agents/runtime-worker.entry.ts สร้าง SQLite VFS, ที่เก็บอาร์ติแฟกต์ของเครื่องมือ, ที่เก็บอาร์ติแฟกต์ของการรัน และที่เก็บแคชแบบจำกัดขอบเขตสำหรับ worker แยกตามการรัน
• สถานะการบูตสแตรปพื้นที่ทำงานเสร็จสมบูรณ์ ความใหม่ของการรับรอง และแฮชบูตสแตรป ที่สร้างขึ้น จะเก็บอยู่ในแถว workspace_setup_state, workspace_path_aliases, workspace_attestations และ workspace_generated_bootstrap_hashes แบบมีชนิดที่ใช้ข้อมูลประจำตัวพื้นที่ทำงาน แบบมาตรฐานเป็นคีย์ นามแฝงเชิงข้อความและนามแฝงพาธจริงที่คงอยู่ช่วยให้ การป้องกันพื้นที่ทำงานที่สูญหายยังคงเสถียรหลัง symlink ที่กำหนดค่าไว้หายไป ส่วนนามแฝงที่เปลี่ยนปลายทางจะล้มเหลวแบบปิด ขณะรันจะไม่อ่านหรือเขียน openclaw-workspace-state.json, .openclaw/workspace-state.json, workspace-attestations/*.attested ในไดเรกทอรีสถานะ หรือไฟล์ประกบ <workspace>.attested อีกต่อไป openclaw doctor --fix จะตรวจสอบและเข้าครอบครองแหล่งข้อมูลเดิม นำเข้าไปยัง SQLite พร้อมใบรับรองการย้ายข้อมูล ตรวจสอบแถวแบบมาตรฐาน แล้วจึงลบไฟล์ที่เข้าครอบครองไว้
• สคีมาที่ใช้ร่วมกันสงวนแถวซิงเกิลตัน exec_approvals_config ไว้ แต่การเปลี่ยน ขณะรันยังอยู่ระหว่างดำเนินการ TypeScript และโปรแกรมคู่หูบน macOS ยังคงใช้ ไฟล์ JSON ที่จำกัดขอบเขตตามสถานะ และต้องย้ายไปยัง SQLite พร้อมกัน
• ขณะนี้ข้อมูลประจำตัวอุปกรณ์ของ TypeScript ใช้แถว device_identities แบบมีชนิด โดยการนำเข้า JSON เดิมที่ใช้เฉพาะ doctor จะอยู่นอกเจ้าของส่วนขณะรัน การยืนยันตัวตน ของอุปกรณ์ยังคงใช้ไฟล์เป็นที่เก็บระหว่างรอการย้ายสคีมาและการย้ายข้อมูลข้ามรันไทม์ ที่ประสานงานกันไว้ โดยยังสงวน device_auth_tokens ไว้สำหรับงานติดตามผลดังกล่าว
• แคชการแลกเปลี่ยนโทเค็น GitHub Copilot ใช้ตารางสถานะ Plugin ของ SQLite ที่ใช้ร่วมกัน ภายใต้ github-copilot/token-cache/default เนื่องจากเป็นสถานะแคชที่ผู้ให้บริการเป็นเจ้าของ จึงตั้งใจไม่เพิ่มตารางลงในสคีมาของโฮสต์
• Compaction ของ GitHub Copilot จะไม่เขียนไฟล์ประกบ openclaw-compaction-*.json ในพื้นที่ทำงานอีกต่อไป harness จะเรียก RPC สำหรับ Compaction ประวัติของ SDK สำหรับเซสชัน SDK ที่ติดตามอยู่ และ OpenClaw จะเก็บสถานะเซสชัน/บทถอดความ แบบคงทนไว้ใน SQLite แทนไฟล์เครื่องหมายความเข้ากันได้
• รันไทม์ Swift ที่ใช้ร่วมกัน (OpenClawKit) ใช้รูปแบบ state/openclaw.sqlite#table/device_identities และคีย์แถวเดียวกันสำหรับข้อมูลประจำตัว อุปกรณ์ ไฟล์เดิมในคอนเทนเนอร์ของ Apple จะถูกนำเข้าโดยเจ้าของการย้ายข้อมูล Swift เนื่องจาก Doctor ของ TypeScript ไม่สามารถเข้าถึงคอนเทนเนอร์เหล่านั้นได้ การยืนยันตัวตน อุปกรณ์ของ Swift ยังคงใช้ไฟล์เป็นที่เก็บสำหรับงานติดตามผลด้านการยืนยันตัวตนที่ประสานงานกันไว้
• ข้อมูลประจำตัวอุปกรณ์ Android และการยืนยันตัวตนอุปกรณ์ที่แคชไว้ยังคงอยู่ในที่เก็บ ภายในแอป โดยต้องมีการย้ายข้อมูลแยกต่างหากที่ Android เป็นเจ้าของ การอ้างสิทธิ์ SQLite ของโฮสต์ไม่ได้อธิบายพฤติกรรม Android ในปัจจุบัน
• ประวัติแพ็กเกจล่าสุดของการแจ้งเตือน Android ใช้แถว android_notification_recent_packages แบบมีชนิด ขณะรันจะไม่ย้ายข้อมูลหรือ อ่านคีย์ CSV ของ SharedPreferences แบบเก่าอีกต่อไป
• การสร้างข้อมูลประจำตัวอุปกรณ์จะล้มเหลวแบบปิดเมื่อมี identity/device.json เดิมอยู่ เมื่อแถวข้อมูลประจำตัวใน SQLite ไม่ถูกต้อง หรือเมื่อไม่สามารถเปิด ที่เก็บข้อมูลประจำตัวใน SQLite ได้ Doctor จะนำเข้าและลบไฟล์นั้นก่อน เพื่อไม่ให้การเริ่มต้น ขณะรันหมุนเวียนข้อมูลประจำตัวสำหรับการจับคู่โดยไม่มีการแจ้งเตือนก่อนการย้ายข้อมูล
• การเลือกข้อมูลประจำตัวอุปกรณ์เป็นคีย์แถวใน SQLite ไม่ใช่ตัวระบุตำแหน่งไฟล์ JSON การทดสอบ และตัวช่วย Gateway จะส่งคีย์ข้อมูลประจำตัวอย่างชัดเจน เฉพาะการย้ายข้อมูลของ doctor และ เกตเริ่มต้นแบบล้มเหลวปิดเท่านั้นที่รู้จักชื่อไฟล์ identity/device.json ที่เลิกใช้แล้ว
• ความเข้ากันได้สำหรับการรีเซ็ตเซสชันอยู่ในการย้ายการกำหนดค่าของ doctor แล้ว: session.idleMinutes ถูกย้ายไปยัง session.reset.idleMinutes, session.resetByType.dm ถูกย้ายไปยัง session.resetByType.direct และนโยบาย รีเซ็ตขณะรันจะอ่านเฉพาะคีย์รีเซ็ตแบบมาตรฐาน
• ความเข้ากันได้ของการกำหนดค่าเดิมอยู่ภายใต้ src/commands/doctor/ แล้ว การตรวจสอบ readConfigFileSnapshot() ตามปกติจะไม่นำเข้าตัวตรวจจับข้อมูลเดิมของ doctor หรือกำกับปัญหาข้อมูลเดิม ส่วน runDoctorConfigPreflight() จะเพิ่มปัญหาเหล่านั้นสำหรับ การซ่อมแซม/การรายงานของ doctor ขั้นตอนการกำหนดค่าของ doctor จะนำเข้า src/commands/doctor/legacy-config.ts และการซ่อมแซมรหัสโปรไฟล์ OAuth แบบเก่าจะอยู่ ภายใต้ src/commands/doctor/legacy/oauth-profile-ids.ts
• คำสั่งที่ไม่ใช่ doctor จะไม่เรียกใช้การซ่อมแซมการกำหนดค่าเดิมโดยอัตโนมัติ ตัวอย่างเช่น ขณะนี้ openclaw update --channel จะล้มเหลวเมื่อพบการกำหนดค่าเดิมที่ไม่ถูกต้อง และขอให้ ผู้ใช้เรียกใช้ doctor แทนการนำเข้าโค้ดการย้ายข้อมูลของ doctor โดยไม่มีการแจ้งเตือน
• ขณะนี้ Web push, APNs, Voice Wake, การตรวจสอบการอัปเดต และสุขภาพการกำหนดค่าใช้ตาราง SQLite แบบมีชนิดที่ใช้ร่วมกันสำหรับการสมัครรับข้อมูล คีย์ VAPID การลงทะเบียน Node แถวทริกเกอร์ แถวการกำหนดเส้นทาง สถานะการแจ้งเตือนการอัปเดต และรายการสุขภาพการกำหนดค่า แทน บล็อบ JSON ทึบแสงทั้งก้อน การเขียนของ Web Push และ APNs จะ upsert เฉพาะแถว คีย์หลักที่ได้รับผลกระทบ ส่วนสุขภาพการกำหนดค่าจะปรับข้อมูลให้สอดคล้องตามพาธการกำหนดค่า โมดูล ขณะรันของส่วนเหล่านี้ยังคงแยกจากตัวช่วยนำเข้า JSON เดิมที่ใช้เฉพาะ Doctor
• ขณะรัน APNs จะอ่านและเขียนเฉพาะ apns_registrations openclaw doctor --fix ที่เรียกใช้อย่างชัดเจนจะนำเข้า push/apns-registrations.json ที่เลิกใช้แล้วอย่างเคร่งครัด รักษาแถวแบบมาตรฐานที่มีอยู่ ตรวจสอบ ธุรกรรม บันทึกใบรับรอง และลบ JSON ที่มีข้อมูลลับ การลองใหม่ที่อ้างอิงใบรับรองจะดำเนินการเฉพาะการทำความสะอาด ขณะที่ apns_registration_tombstones ครอบคลุมการทำให้ใช้ไม่ได้ก่อนการซ่อมแซมครั้งแรก เพื่อไม่ให้ สิทธิ์อนุญาตรีเลย์หรือโทเค็นอุปกรณ์ที่ล้าสมัยกลับมาทำงานได้อีก
• ขณะนี้การกำหนดค่าโฮสต์ Node ใช้แถวซิงเกิลตันแบบมีชนิดในฐานข้อมูล SQLite ที่ใช้ร่วมกัน ขณะรันจะล้มเหลวแบบปิดตราบใดที่ยังมีไฟล์ node.json เก่าหรือการเข้าครอบครอง ที่ถูกขัดจังหวะอยู่ ส่วน openclaw doctor --fix ที่เรียกใช้อย่างชัดเจนจะนำเข้าและลบไฟล์ดังกล่าว อย่างเคร่งครัดก่อนการใช้งานขณะรันตามปกติ
• ขณะนี้การจับคู่อุปกรณ์/Node การจับคู่ช่องทาง รายการอนุญาตของช่องทาง และสถานะบูตสแตรป ใช้แถว SQLite แบบมีชนิดแทนบล็อบ JSON ทึบแสงทั้งก้อน การอนุมัติการผูก Plugin และสถานะงาน Cron ใช้การแบ่งแบบเดียวกัน กล่าวคือ โมดูลขณะรันจะเปิดเผย การดำเนินการที่ใช้ SQLite เป็นที่เก็บและตัวช่วยสแนปช็อตที่เป็นกลาง และการเขียนสแนปช็อต สำหรับการจับคู่/บูตสแตรป รวมถึงการอนุมัติการผูก Plugin จะปรับแถวให้สอดคล้องตามคีย์หลัก แทนการตัดข้อมูลในตาราง ขณะที่ doctor นำเข้า/ลบไฟล์ JSON เก่าผ่านโมดูล src/commands/doctor/legacy/*
• ขณะนี้ระเบียน Plugin ที่ติดตั้งแล้วอยู่ในดัชนี Plugin ที่ติดตั้งของ SQLite การอ่าน/เขียนการกำหนดค่าขณะรันจะไม่ย้ายหรือเก็บรักษาข้อมูลการกำหนดค่าที่สร้างขึ้นแบบเก่า ใน plugins.installs อีกต่อไป โดย doctor จะนำเข้ารูปแบบการกำหนดค่าเดิมดังกล่าว ไปยัง SQLite ก่อนการใช้งานขณะรันตามปกติ
• ขณะนี้สแนปช็อตการกู้คืนข้อมูลรับรอง QQBot อยู่ในสถานะ Plugin ของ SQLite ภายใต้ qqbot/credential-backups ขณะรันจะไม่เขียน qqbot/data/credential-backup*.json อีกต่อไป สัญญา doctor ของ QQBot จะนำเข้าและ เก็บถาวรไฟล์สำรองเดิมเหล่านั้นจากไดเรกทอรีสถานะที่ใช้งานอยู่
• การวางแผนโหลด Gateway ใหม่จะเปรียบเทียบสแนปช็อตดัชนี Plugin ที่ติดตั้งใน SQLite ภายใต้ เนมสเปซ diff ภายใน installedPluginIndex.installRecords.* การตัดสินใจ โหลดใหม่ขณะรันจะไม่ห่อแถวเหล่านั้นด้วยออบเจ็กต์การกำหนดค่า plugins.installs ปลอมอีกต่อไป
• ขณะนี้ข้อมูลรับรองบัญชี Matrix อยู่ในสถานะ Plugin ของ SQLite ขณะรันจะอ่าน เฉพาะที่เก็บแบบมาตรฐานดังกล่าว ส่วน Doctor จะนำเข้า ตรวจสอบ และเก็บถาวรไฟล์ credentials/matrix/credentials*.json ที่เลิกใช้แล้วเมื่อสามารถระบุบัญชีของไฟล์เหล่านั้นได้
• โมดูลขณะรันสำหรับการจับคู่หลักและ Cron จะไม่ใช้ตัวสร้างพาธ JSON เดิมอีกต่อไป ตัวช่วย SDK สำหรับพาธการจับคู่ที่เลิกใช้แล้วยังคงมีไว้เพื่อความเข้ากันได้สำหรับการย้ายข้อมูลเท่านั้น การย้ายสถานะของ doctor เป็นเจ้าของการอ่านและนำเข้าไฟล์ดังกล่าว โมดูลข้อมูลเดิมที่ doctor เป็นเจ้าของจะสร้างพาธต้นทาง pending.json, paired.json, bootstrap.json และ cron/jobs.json สำหรับการทดสอบการนำเข้าและการย้ายข้อมูลเท่านั้น การปรับรูปแบบงาน Cron เดิมให้เป็นมาตรฐานและการนำเข้าประวัติ JSONL อยู่ภายใต้ src/commands/doctor/cron/ ส่วนการทำให้ประวัติ SQLite เดิมเสร็จสมบูรณ์จะทำงานระหว่าง การเปิดฐานข้อมูลสถานะ
• src/commands/doctor/legacy/runtime-state.ts นำเข้าไฟล์สถานะ JSON เดิม รวมถึงการกำหนดค่าโฮสต์ Node ไปยัง SQLite จาก doctor ตัวนำเข้าไฟล์เดิมใหม่ จะอยู่ภายใต้ src/commands/doctor/legacy/
• src/commands/doctor/state-migrations.ts นำเข้าบทถอดความ sessions.json และ *.jsonl เดิมไปยัง SQLite โดยตรง และลบแหล่งข้อมูลที่นำเข้าสำเร็จ โดยจะไม่พักบทถอดความเดิมระดับรูทผ่าน agents/<agentId>/sessions/*.jsonl หรือสร้างเป้าหมาย JSONL แบบมาตรฐานก่อน การนำเข้าอีกต่อไป
• การตรวจสอบความสมบูรณ์ของสถานะโดย doctor จะไม่สแกนไดเรกทอรีเซสชันเดิมหรือ เสนอให้ลบ JSONL กำพร้าอีกต่อไป ไฟล์บทถอดความเดิมเป็นเพียงข้อมูลนำเข้าสำหรับการย้ายข้อมูล และขั้นตอนการย้ายข้อมูลเป็นเจ้าของทั้งการนำเข้าและการลบแหล่งข้อมูล
• การนำเข้ารีจิสทรี sandbox เดิมอยู่ภายใต้ src/commands/doctor/legacy/sandbox-registry.ts ส่วนการอ่านและเขียนรีจิสทรี sandbox ที่ใช้งานอยู่จะยังคงใช้ SQLite เท่านั้น
• การซ่อมแซมสุขภาพ/การนำเข้าบทถอดความเซสชันเดิมอยู่ภายใต้ src/commands/doctor/legacy/session-transcript-health.ts โมดูลคำสั่งขณะรัน จะไม่มีโค้ดแยกวิเคราะห์บทถอดความ JSONL หรือซ่อมแซมสาขาที่ใช้งานอยู่อีกต่อไป

ไฮไลต์ของการรวมและการลบที่เสร็จสมบูรณ์:

• สถานะ Plugin ใช้ฐานข้อมูล state/openclaw.sqlite ที่ใช้ร่วมกันแล้ว ตัวนำเข้า sidecar แบบ plugin-state/state.sqlite เฉพาะ branch เดิมถูกนำออก เนื่องจากโครงสร้าง SQLite ดังกล่าวไม่เคยเผยแพร่ ตัวช่วย probe/test รายงาน databasePath ที่ใช้ร่วมกันแทนการเปิดเผยพาธ SQLite เฉพาะสำหรับสถานะ Plugin
• ตารางรันไทม์ของงานและ Task Flow อยู่ในฐานข้อมูล state/openclaw.sqlite ที่ใช้ร่วมกันแล้ว แทน tasks/runs.sqlite และ tasks/flows/registry.sqlite; ตัวนำเข้า sidecar เดิมถูกนำออกด้วยเหตุผลเดียวกันคือโครงสร้างดังกล่าวไม่เคยเผยแพร่
• src/config/sessions/store.ts ไม่ต้องใช้ storePath สำหรับเมทาดาทาขาเข้า การอัปเดตเส้นทาง หรือการอ่านเวลาอัปเดตล่าสุดอีกต่อไป การคงอยู่ของคำสั่ง การล้างเซสชัน CLI ความลึกของ subagent การแทนที่ค่าการยืนยันตัวตน และข้อมูลประจำตัวของเซสชัน transcript ใช้ API แถวของเอเจนต์/เซสชัน การเขียนถูกนำไปใช้เป็นแพตช์แถว SQLite พร้อมลองใหม่เมื่อเกิดข้อขัดแย้งแบบ optimistic
• การแก้ไขเป้าหมายเซสชันเปิดเผยเป้าหมายฐานข้อมูลแยกตามเอเจนต์แล้ว ไม่ใช่พาธ sessions.json แบบเดิม Gateway ที่ใช้ร่วมกัน เมทาดาทา ACP การซ่อมแซมเส้นทางของ doctor และ openclaw sessions แจกแจง agent_databases รวมถึงเอเจนต์ที่กำหนดค่าไว้
• การกำหนดเส้นทางเซสชันของ Gateway ใช้ resolveGatewaySessionDatabaseTarget แล้ว; เป้าหมายที่ส่งกลับมี databasePath และคีย์แถว SQLite ที่เป็นไปได้ แทนพาธไฟล์ที่เก็บเซสชันแบบเดิม
• ชนิดรันไทม์เซสชันของช่องทางเปิดเผย {agentId, sessionKey} สำหรับการอ่านเวลาอัปเดตล่าสุด เมทาดาทาขาเข้า และการอัปเดตเส้นทางล่าสุดแล้ว ชนิดความเข้ากันได้ saveSessionStore(storePath, store) แบบเดิมถูกนำออกแล้ว
• พื้นผิวเซสชันของรันไทม์ Plugin, API ส่วนขยาย และ SDK ของ Plugin เปิดเผยตัวช่วยแถวเซสชันที่มี SQLite รองรับแล้ว แทนตัวช่วยความเข้ากันได้แบบทั้งพื้นที่จัดเก็บ/ไฟล์ของเซสชันที่ใช้งานอยู่ การส่งออกความเข้ากันได้ของไลบรารีรากยังคงใช้ได้เฉพาะภายนอก SDK ของ Plugin สำหรับผู้เรียกใช้ภายในแบบเดิมและผู้เรียกใช้การย้ายข้อมูล ตัวช่วย resolveLegacySessionStorePath แบบเดิมถูกนำออกแล้ว; การสร้างพาธ sessions.json แบบเดิมอยู่เฉพาะในการย้ายข้อมูลและฟิกซ์เจอร์ทดสอบแล้ว
• src/config/sessions/session-entries.sqlite.ts จัดเก็บรายการเซสชันมาตรฐานในฐานข้อมูลแยกตามเอเจนต์แล้ว และรองรับแพตช์การอ่าน/upsert/ลบระดับแถว การ upsert/แพตช์/ลบขณะรันไทม์จะไม่สแกนหารูปแบบตัวพิมพ์ที่แตกต่างกันหรือตัดคีย์นามแฝงแบบเดิมอีกต่อไป; doctor เป็นเจ้าของการทำให้เป็นมาตรฐาน ตัวช่วยนำเข้า JSON แบบแยกเดี่ยวถูกนำออกแล้ว และการย้ายข้อมูลจะผสานโดย upsert แถวที่ใหม่กว่าแทนการแทนที่ตารางเซสชันทั้งหมด ตัวช่วยอ่าน/แสดงรายการ/โหลดสาธารณะฉายเมทาดาทาเซสชันที่ใช้งานบ่อยจากแถว sessions และ conversations ที่มีชนิด; entry_json เป็นเงาสำหรับความเข้ากันได้/การดีบัก และอาจเก่าหรือไม่ถูกต้องได้โดยไม่ทำให้ข้อมูลประจำตัวของเซสชันหรือบริบทการส่งที่มีชนิดสูญหาย
• src/config/sessions/delivery-info.ts แก้ไขบริบทการส่งจากแถว sessions + conversations + session_conversations แยกตามเอเจนต์ที่มีชนิดแล้ว โดยจะไม่สร้างข้อมูลประจำตัวการส่งขณะรันไทม์ขึ้นใหม่จาก session_entries.entry_json อีกต่อไป; การไม่มีแถวการสนทนาที่มีชนิดเป็นปัญหาการย้ายข้อมูล/ซ่อมแซมของ doctor ไม่ใช่ fallback ขณะรันไทม์
• การตัดสินใจรีเซ็ตเซสชันที่จัดเก็บไว้ให้ความสำคัญกับเมทาดาทา sessions.session_scope, sessions.chat_type และ sessions.channel ที่มีชนิดแล้ว การแยกวิเคราะห์ sessionKey ยังคงมีไว้เฉพาะสำหรับส่วนต่อท้ายเธรด/หัวข้อที่ระบุอย่างชัดเจนบนเป้าหมายคำสั่ง; การจำแนกการรีเซ็ตแบบกลุ่มเทียบกับแบบโดยตรงจะไม่ได้มาจากรูปทรงของคีย์อีกต่อไป
• การจำแนกการแสดงรายการ/สถานะเซสชันใช้เมทาดาทาแชตที่มีชนิดและชนิดเซสชันของ Gateway แล้ว โดยจะไม่ถือว่าสตริงย่อย :group: หรือ :channel: ภายใน session_key เป็นข้อเท็จจริงถาวรว่าเป็นกลุ่ม/โดยตรงอีกต่อไป
• การเลือกนโยบายการตอบกลับแบบเงียบใช้เฉพาะชนิดการสนทนาหรือเมทาดาทาพื้นผิวที่ระบุอย่างชัดเจนแล้ว โดยจะไม่คาดเดานโยบายแบบโดยตรง/กลุ่มจากสตริงย่อย session_key อีกต่อไป
• การแก้ไขโมเดลการแสดงเซสชันรับรหัสเอเจนต์จากเป้าหมายฐานข้อมูลเซสชัน SQLite แล้ว แทนการแยกออกจาก session_key
• การเติมข้อมูลเป้าหมายประกาศระหว่างเอเจนต์ใช้เฉพาะ sessions.list deliveryContext ที่มีชนิดแล้ว โดยจะไม่กู้คืนการกำหนดเส้นทางช่องทาง/บัญชี/เธรดจาก origin แบบเดิม ฟิลด์เงา last* หรือรูปทรง session_key อีกต่อไป
• การปฏิเสธเป้าหมายเธรดของ sessions_send อ่านเมทาดาทาการกำหนดเส้นทาง SQLite ที่มีชนิดแล้ว โดยจะไม่ปฏิเสธหรือยอมรับเป้าหมายด้วยการแยกวิเคราะห์ส่วนต่อท้ายเธรดออกจากคีย์เป้าหมายอีกต่อไป
• การตรวจสอบนโยบายเครื่องมือที่มีขอบเขตระดับกลุ่มอ่านการกำหนดเส้นทางการสนทนา SQLite ที่มีชนิดสำหรับเซสชันปัจจุบันหรือเซสชันที่สร้างขึ้นแล้ว โดยจะไม่เชื่อถือข้อมูลประจำตัวของกลุ่ม/ช่องทางจากการถอดรหัส sessionKey อีกต่อไป; รหัสกลุ่มที่ผู้เรียกใช้ระบุจะถูกละทิ้งเมื่อไม่มีแถวเซสชันที่มีชนิดรับรอง
• การจับคู่การแทนที่โมเดลของช่องทางใช้เมทาดาทาการสนทนาแบบกลุ่มและแบบแม่ที่ระบุอย่างชัดเจนแล้ว โดยจะไม่ถอดรหัสรหัสการสนทนาแม่จาก parentSessionKey อีกต่อไป
• การสืบทอดการแทนที่โมเดลที่จัดเก็บไว้ต้องมีคีย์เซสชันแม่ที่ระบุอย่างชัดเจนจากบริบทเซสชันที่มีชนิดแล้ว โดยจะไม่อนุมานการแทนที่จากเซสชันแม่จากส่วนต่อท้าย :thread: หรือ :topic: ใน sessionKey อีกต่อไป
• ตัวห่อข้อมูลเธรดเซสชันแบบเดิมและตัวแยกวิเคราะห์เธรดของ Plugin ที่โหลดแล้วถูกนำออก; ไม่มีโค้ดรันไทม์ใดนำเข้า config/sessions/thread-info
• ตัวช่วยการสนทนาของช่องทางไม่เปิดเผยบริดจ์การแยกวิเคราะห์คีย์เซสชันแบบเต็มอีกต่อไป Core ยังคงทำให้รหัสการสนทนาดิบที่ผู้ให้บริการเป็นเจ้าของเป็นมาตรฐานผ่าน resolveSessionConversation(...) แต่จะไม่สร้างข้อเท็จจริงของเส้นทางขึ้นใหม่จาก sessionKey
• การส่งผลลัพธ์เมื่อเสร็จสิ้น นโยบายการส่ง และการบำรุงรักษางานจะไม่อนุมานชนิดแชตจากรูปทรง session_key อีกต่อไป ตัวแยกวิเคราะห์คีย์ชนิดแชตแบบเดิมถูกลบแล้ว; เส้นทางเหล่านี้ต้องใช้เมทาดาทาเซสชันที่มีชนิด บริบทการส่งที่มีชนิด หรือคำศัพท์เป้าหมายการส่งที่ระบุอย่างชัดเจน
• รายการ/สถานะเซสชัน การวินิจฉัย การผูกบัญชีการอนุมัติ การกรอง Heartbeat ของ TUI และสรุปการใช้งานจะไม่ขุดค้น SessionEntry.origin เพื่อหาการกำหนดเส้นทางผู้ให้บริการ/บัญชี/เธรด/การแสดงผลอีกต่อไป การอ่าน origin ขณะรันไทม์ที่เหลืออยู่มีเฉพาะแนวคิดที่ไม่ใช่เซสชันหรือออบเจ็กต์การส่งของเทิร์นปัจจุบัน
• การค้นหาการสนทนาแบบเนทีฟสำหรับคำขออนุมัติอ่านแถวการกำหนดเส้นทางเซสชันแยกตามเอเจนต์ที่มีชนิดแล้ว โดยจะไม่แยกวิเคราะห์ข้อมูลประจำตัวการสนทนาแบบช่องทาง/กลุ่ม/เธรดจาก sessionKey อีกต่อไป; การไม่มีเมทาดาทาที่มีชนิดเป็นปัญหาการย้ายข้อมูล/ซ่อมแซม
• เพย์โหลดเหตุการณ์เซสชันเปลี่ยนแปลง/แชต/เซสชันของ Gateway จะไม่สะท้อนเงาเส้นทาง SessionEntry.origin หรือ last* อีกต่อไป; ไคลเอนต์ได้รับ channel, chatType และ deliveryContext ที่มีชนิด
• การแก้ไขการส่ง Heartbeat สามารถรับ deliveryContext ของ SQLite ที่มีชนิดได้โดยตรงแล้ว และรันไทม์ Heartbeat ส่งแถวการส่งของเซสชันแยกตามเอเจนต์ แทนการพึ่งพาเงาความเข้ากันได้ session_entries สำหรับการกำหนดเส้นทางปัจจุบัน
• การแก้ไขเป้าหมายการส่งของเอเจนต์แยกของ Cron ยังเติมข้อมูลเส้นทางปัจจุบันจากแถวการส่งเซสชันแยกตามเอเจนต์ที่มีชนิด ก่อน fallback ไปยังเพย์โหลดรายการความเข้ากันได้
• การแก้ไขต้นทางประกาศของ subagent ส่งต่อบริบทการส่งของเซสชันผู้ร้องขอที่มีชนิดผ่าน loadRequesterSessionEntry แล้ว และให้ความสำคัญกับแถวดังกล่าวเหนือเงาความเข้ากันได้ last*/deliveryContext
• การอัปเดตเมทาดาทาเซสชันขาเข้าผสานกับแถวการส่งแยกตามเอเจนต์ที่มีชนิดก่อน; ฟิลด์การส่ง SessionEntry แบบเดิมเป็นเพียง fallback เมื่อไม่มีแถวการสนทนาที่มีชนิด
• การแยกข้อมูลการส่งสำหรับการรีสตาร์ต/อัปเดตให้ threadId การส่งของ SQLite ที่มีชนิดมีลำดับความสำคัญเหนือส่วนย่อยหัวข้อ/เธรดที่แยกวิเคราะห์จาก sessionKey; การแยกวิเคราะห์เป็นเพียง fallback สำหรับคีย์รูปทรงเธรดแบบเดิม
• รหัสช่องทางของบริบทเอเจนต์ใน hook ให้ความสำคัญกับข้อมูลประจำตัวการสนทนา SQLite ที่มีชนิด แล้วจึงใช้เมทาดาทาข้อความที่ระบุอย่างชัดเจน โดยจะไม่แยกวิเคราะห์ส่วนย่อยผู้ให้บริการ/กลุ่ม/ช่องทางจาก sessionKey อีกต่อไป
• การสืบทอดเส้นทางภายนอกของ chat.send ใน Gateway อ่านเมทาดาทาการกำหนดเส้นทางเซสชัน SQLite ที่มีชนิดแล้ว แทนการอนุมานขอบเขตช่องทาง/โดยตรง/กลุ่มจากส่วนประกอบ sessionKey เซสชันที่มีขอบเขตระดับช่องทางจะสืบทอดเฉพาะเมื่อช่องทางเซสชันและชนิดแชตที่มีชนิดตรงกับบริบทการส่งที่จัดเก็บไว้; เซสชันหลักที่ใช้ร่วมกันยังคงกฎ CLI/ไม่มีเมทาดาทาไคลเอนต์ที่เข้มงวดกว่า
• การปลุกด้วย restart sentinel และการกำหนดเส้นทางต่อเนื่องอ่านแถวการส่ง/การกำหนดเส้นทาง SQLite ที่มีชนิดแล้ว ก่อนเข้าคิวการปลุก Heartbeat หรือการดำเนินเทิร์นของเอเจนต์ต่อที่มีการกำหนดเส้นทาง โดยจะไม่สร้างบริบทการส่งขึ้นใหม่จากเงา JSON ของรายการเซสชันอีกต่อไป
• การแก้ไขบริบท tools.effective ของ Gateway อ่านแถวการส่ง/การกำหนดเส้นทาง SQLite ที่มีชนิดสำหรับอินพุตผู้ให้บริการ บัญชี เป้าหมาย เธรด และโหมดตอบกลับแล้ว โดยจะไม่กู้คืนฟิลด์การกำหนดเส้นทางที่ใช้งานบ่อยเหล่านั้นจากเงาต้นทาง session_entries.entry_json ที่เก่าอีกต่อไป
• การกำหนดเส้นทางการปรึกษาด้วยเสียงแบบเรียลไทม์แก้ไขการส่งของเซสชันแม่/การโทรจากแถวเซสชัน SQLite แยกตามเอเจนต์ที่มีชนิดแล้ว โดยจะไม่ fallback ไปยังเงาความเข้ากันได้ SessionEntry.deliveryContext อีกต่อไป เมื่อเลือกเส้นทางข้อความของเอเจนต์แบบฝัง
• รีเลย์ Heartbeat สำหรับการสร้าง ACP และการกำหนดเส้นทางสตรีมแม่อ่านการส่งของเซสชันแม่จากแถวเซสชัน SQLite ที่มีชนิดแล้ว โดยจะไม่สร้างบริบทการส่งของเซสชันแม่ขึ้นใหม่จากเงารายการเซสชันเพื่อความเข้ากันได้อีกต่อไป
• การรักษาเส้นทางการส่งของเซสชันเป็นไปตามเมทาดาทาแชตที่มีชนิดและคอลัมน์การส่งที่คงอยู่แล้ว โดยจะไม่แยกคำใบ้ช่องทาง เครื่องหมายโดยตรง/หลัก หรือรูปทรงเธรดจาก sessionKey อีกต่อไป; เส้นทางเว็บแชตภายในจะสืบทอดเป้าหมายภายนอกเฉพาะเมื่อ SQLite มีข้อมูลประจำตัวการส่งที่มีชนิด/คงอยู่สำหรับเซสชันอยู่แล้ว
• การแยกข้อมูลการส่งของเซสชันทั่วไปอ่านเฉพาะแถวการส่งเซสชัน SQLite ที่มีชนิดและตรงกันทุกประการ โดยจะไม่แยกวิเคราะห์ส่วนต่อท้ายเธรด/หัวข้อหรือ fallback จากคีย์รูปทรงเธรดไปยังคีย์เซสชันฐานอีกต่อไป
• การส่งต่อการตอบกลับ การกู้คืน restart sentinel และการกำหนดเส้นทางการปรึกษาด้วยเสียงแบบเรียลไทม์ใช้แถวเซสชัน/การสนทนา SQLite ที่มีชนิดและตรงกันทุกประการสำหรับการกำหนดเส้นทางเธรดแล้ว โดยจะไม่กู้คืนรหัสเธรดหรือบริบทการส่งของเซสชันฐานด้วยการแยกวิเคราะห์คีย์เซสชันรูปทรงเธรดอีกต่อไป
• การจำกัดประวัติ PI แบบฝังใช้การฉายการกำหนดเส้นทางเซสชัน SQLite ที่มีชนิด (sessions + conversations หลัก) สำหรับผู้ให้บริการ ชนิดแชต และข้อมูลประจำตัวเพียร์แล้ว โดยจะไม่แยกวิเคราะห์รูปทรงผู้ให้บริการ DM กลุ่ม หรือเธรดออกจาก sessionKey อีกต่อไป
• การอนุมานการส่งของเครื่องมือ Cron ใช้การส่งที่ระบุอย่างชัดเจนหรือเฉพาะบริบทการส่งปัจจุบันที่มีชนิดแล้ว โดยจะไม่ถอดรหัสเป้าหมายช่องทาง เพียร์ บัญชี หรือเธรดจาก agentSessionKey อีกต่อไป
• แถวเซสชันขณะรันไทม์ไม่มีนามแฝงเส้นทาง lastProvider แบบเดิมอีกต่อไป ตัวช่วยและการทดสอบใช้ฟิลด์ lastChannel และ deliveryContext ที่มีชนิด; การย้ายข้อมูลของ doctor เป็นเพียงที่เดียวที่ควรแปลงนามแฝงเส้นทางเก่าหรือเงา origin ที่คงอยู่
• เหตุการณ์ transcript แถว VFS และแถวอาร์ติแฟกต์เครื่องมือเขียนลงฐานข้อมูลแยกตามเอเจนต์แล้ว ตารางการแมปไฟล์ transcript ส่วนกลางที่ไม่เคยเผยแพร่ถูกนำออก; doctor บันทึกพาธต้นทางแบบเดิมในแถวการย้ายข้อมูลถาวรแทน
• การค้นหา transcript ขณะรันไทม์จะไม่สแกนออฟเซ็ตไบต์ JSONL หรือตรวจหาไฟล์ transcript แบบเดิมอีกต่อไป เส้นทางแชต/สื่อ/ประวัติของ Gateway อ่านแถว transcript จาก SQLite; JSONL ของเซสชันเป็นเพียงอินพุตแบบเดิมของ doctor แล้ว ไม่ใช่สถานะขณะรันไทม์หรือรูปแบบการส่งออก
• ความสัมพันธ์ระหว่างเซสชันแม่และ branch ของ transcript ใช้เมทาดาทา parentTranscriptScope: {agentId, sessionId} แบบมีโครงสร้างในส่วนหัว transcript ของ SQLite ไม่ใช่สตริงตัวระบุตำแหน่ง agent-db:...transcript_events... ที่มีลักษณะคล้ายพาธ
• สัญญาของตัวจัดการ transcript ไม่เปิดเผยคอนสตรักเตอร์ create(cwd) หรือ continueRecent(cwd) ที่คงอยู่โดยปริยายอีกต่อไป ตัวจัดการ transcript ที่คงอยู่จะเปิดด้วยขอบเขต {agentId, sessionId} ที่ระบุอย่างชัดเจน; เฉพาะ ตัวจัดการในหน่วยความจำยังคงไม่ผูกกับขอบเขตสำหรับการทดสอบและการแปลงทรานสคริปต์แบบบริสุทธิ์
• API ของที่เก็บทรานสคริปต์ขณะรันไทม์จะระบุขอบเขต SQLite ไม่ใช่พาธระบบไฟล์ ตัวช่วย resolve...ForPath เดิมและตัวเลือกการเขียน transcriptPath ที่ไม่ได้ใช้ ถูกนำออกจากผู้เรียกขณะรันไทม์แล้ว
• ขณะนี้การระบุเซสชันขณะรันไทม์ใช้ {agentId, sessionId} และต้องไม่สร้าง สตริง sqlite-transcript://<agent>/<session> สำหรับขอบเขตภายนอก พาธ JSONL แบบสัมบูรณ์รุ่นเก่าเป็นอินพุตสำหรับการย้ายข้อมูลของ doctor เท่านั้น
• ขณะนี้ระเบียน direct-bridge ของรีเลย์ฮุกแบบเนทีฟอยู่ในแถว native_hook_relay_bridges ที่ใช้ร่วมกันแบบมีชนิดข้อมูล โดยกำหนดคีย์ตามรหัสรีเลย์ รันไทม์จะไม่เขียนรีจิสทรี JSON /tmp หรือระเบียนทั่วไปแบบทึบสำหรับระเบียนบริดจ์อายุสั้นเหล่านั้นอีกต่อไป
• runEmbeddedPiAgent(...) ไม่มีพารามิเตอร์ตัวระบุตำแหน่งทรานสคริปต์อีกต่อไป ตัวอธิบายเวิร์กเกอร์ที่เตรียมไว้ก็ละเว้นตัวระบุตำแหน่งทรานสคริปต์เช่นกัน สถานะเซสชันขณะรันไทม์ และการรันติดตามผลที่อยู่ในคิวจะเก็บ {agentId, sessionId} แทน แฮนเดิลทรานสคริปต์ที่สร้างขึ้น
• ขณะนี้ Compaction แบบฝังตัวรับขอบเขต SQLite จาก agentId และ sessionId ฮุก Compaction, การเรียกเอนจินบริบท, การมอบหมาย CLI และการตอบกลับของโปรโตคอล ต้องไม่ได้รับแฮนเดิล sqlite-transcript://... ที่สร้างขึ้น โค้ดส่งออก/ดีบัก สามารถสร้างอาร์ติแฟกต์ผู้ใช้ที่ระบุชัดเจนจากแถวได้ แต่จะไม่จัดเตรียม พาธส่งออก JSONL ของเซสชันแบบทั่วไปหรือส่งชื่อไฟล์กลับเข้าไปเป็นข้อมูลระบุตัวตน ของรันไทม์
• /export-session อ่านแถวทรานสคริปต์จาก SQLite และเขียนเฉพาะมุมมอง HTML แบบสแตนด์อโลนที่ร้องขอเท่านั้น ตัวแสดงผลแบบฝังตัวจะไม่สร้างหรือ ดาวน์โหลด JSONL ของเซสชันจากแถวเหล่านั้นอีกต่อไป
• การมอบหมายไปยังเอนจินบริบทจะไม่แยกวิเคราะห์ตัวระบุตำแหน่งทรานสคริปต์เพื่อกู้คืน ข้อมูลระบุตัวตนของเอเจนต์อีกต่อไป บริบทรันไทม์ที่เตรียมไว้จะส่ง agentId ที่ระบุแล้วไปยังอะแดปเตอร์ Compaction ในตัว
• ขณะนี้การเขียนทรานสคริปต์ใหม่และการตัดผลลัพธ์เครื่องมือแบบสดจะอ่านและคงสถานะ ทรานสคริปต์ตาม {agentId, sessionId} และไม่สร้างตัวระบุตำแหน่งชั่วคราว สำหรับเพย์โหลดเหตุการณ์อัปเดตทรานสคริปต์
• พื้นผิวตัวช่วยสถานะทรานสคริปต์ไม่มีตัวแปรแบบอิงตัวระบุตำแหน่ง readTranscriptState, replaceTranscriptStateEvents หรือ persistTranscriptStateMutation อีกต่อไป ผู้เรียกขณะรันไทม์ต้องใช้ API {agentId, sessionId} การนำเข้าของ doctor จะอ่านไฟล์รุ่นเก่าด้วยพาธไฟล์ที่ระบุชัดเจน และเขียนแถว SQLite โดยจะไม่ย้ายสตริงตัวระบุตำแหน่ง
• สัญญาตัวจัดการเซสชันขณะรันไทม์จะไม่เปิดเผย open(locator), forkFrom(locator) หรือ setTranscriptLocator(...) อีกต่อไป ตัวจัดการเซสชัน แบบคงอยู่จะเปิดด้วย {agentId, sessionId} เท่านั้น ตัวช่วยแสดงรายการ/ฟอร์กอยู่ใน API เซสชันและเช็กพอยต์แบบมุ่งเน้นแถว แทนที่จะอยู่ในฟาซาดตัวจัดการทรานสคริปต์
• API ตัวอ่านทรานสคริปต์ของ Gateway ให้ความสำคัญกับขอบเขตก่อน โดยรับ {agentId, sessionId} และไม่รับตัวระบุตำแหน่งทรานสคริปต์แบบตำแหน่งที่อาจ กลายเป็นข้อมูลระบุตัวตนของรันไทม์โดยไม่ตั้งใจ การแยกวิเคราะห์ตัวระบุตำแหน่งทรานสคริปต์ที่ใช้งานอยู่ ถูกนำออกแล้ว พาธต้นทางรุ่นเก่าจะอ่านโดยโค้ดนำเข้าของ doctor เท่านั้น
• เหตุการณ์อัปเดตทรานสคริปต์ให้ความสำคัญกับขอบเขตก่อนเช่นกัน emitSessionTranscriptUpdate จะไม่รับสตริงตัวระบุตำแหน่งเปล่าอีกต่อไป และตัวฟังจะกำหนดเส้นทางตาม {agentId, sessionId} โดยไม่แยกวิเคราะห์แฮนเดิล
• การบรอดแคสต์ข้อความเซสชันของ Gateway จะระบุคีย์เซสชันจากขอบเขตเอเจนต์/เซสชัน ไม่ใช่จากตัวระบุตำแหน่งทรานสคริปต์ ตัวระบุ/แคชแบบเดิมที่แปลงตัวระบุตำแหน่งทรานสคริปต์ เป็นคีย์เซสชันถูกนำออกแล้ว
• ตัวกรอง SSE ของประวัติเซสชัน Gateway จะกรองการอัปเดตแบบสดตามขอบเขตเอเจนต์/เซสชัน โดยจะไม่ ทำตัวเลือกตัวระบุตำแหน่งทรานสคริปต์ พาธจริง หรือข้อมูลระบุตัวตนทรานสคริปต์ ที่มีรูปแบบเหมือนไฟล์ให้เป็นรูปแบบมาตรฐานอีกต่อไป เพื่อตัดสินใจว่าสตรีมควรได้รับการอัปเดตหรือไม่
• ฮุกวงจรชีวิตเซสชันจะไม่สร้างหรือเปิดเผยตัวระบุตำแหน่งทรานสคริปต์บน session_end อีกต่อไป ผู้ใช้ฮุกจะได้รับ sessionId, sessionKey, รหัสเซสชัน ถัดไป และบริบทเอเจนต์ โดยไฟล์ทรานสคริปต์ไม่เป็นส่วนหนึ่งของสัญญาวงจรชีวิต
• ฮุกรีเซ็ตจะไม่สร้างหรือเปิดเผยตัวระบุตำแหน่งทรานสคริปต์เช่นกัน เพย์โหลด before_reset จะเก็บข้อความ SQLite ที่กู้คืนพร้อมเหตุผลในการรีเซ็ต ขณะที่ข้อมูลระบุตัวตนของเซสชันยังคงอยู่ในบริบทฮุก
• การรีเซ็ตชุดทดสอบเอเจนต์จะไม่รับตัวระบุตำแหน่งทรานสคริปต์อีกต่อไป การส่งรีเซ็ต จะกำหนดขอบเขตด้วย sessionId/sessionKey พร้อมเหตุผล
• ชนิดเซสชันของส่วนขยายเอเจนต์จะไม่เปิดเผย transcriptLocator อีกต่อไป ส่วนขยาย ควรใช้บริบทเซสชันและ API ขณะรันไทม์ แทนการเข้าถึงข้อมูลระบุตัวตนทรานสคริปต์ ที่มีรูปแบบเหมือนไฟล์
• ฮุก Compaction ของ Plugin จะไม่เปิดเผยตัวระบุตำแหน่งทรานสคริปต์อีกต่อไป บริบทฮุก มีข้อมูลระบุตัวตนของเซสชันอยู่แล้ว และการอ่านทรานสคริปต์ต้องดำเนินการผ่าน API ที่รับรู้ขอบเขต SQLite แทนแฮนเดิลที่มีรูปแบบเหมือนไฟล์
• ฮุก before_agent_finalize จะไม่เปิดเผย transcriptPath อีกต่อไป รวมถึง เพย์โหลดรีเลย์ฮุกแบบเนทีฟ ฮุกการปิดท้ายใช้เฉพาะบริบทเซสชัน
• การตอบกลับการรีเซ็ตของ Gateway จะไม่สังเคราะห์ตัวระบุตำแหน่งทรานสคริปต์บนรายการ ที่ส่งคืนอีกต่อไป การรีเซ็ตจะสร้างแถวทรานสคริปต์ SQLite ส่งคืนรายการเซสชัน ที่สะอาด และปล่อยให้การเข้าถึงทรานสคริปต์เป็นหน้าที่ของตัวอ่านที่รับรู้ขอบเขต
• ผลลัพธ์การรันและ Compaction แบบฝังตัวจะไม่แสดงตัวระบุตำแหน่งทรานสคริปต์สำหรับ การทำบัญชีเซสชันอีกต่อไป Compaction อัตโนมัติจะอัปเดตเฉพาะ sessionId ที่ใช้งานอยู่ ตัวนับ Compaction และเมทาดาทาโทเค็น
• ผลลัพธ์ความพยายามแบบฝังตัวจะไม่ส่งคืน transcriptLocatorUsed อีกต่อไป และ ผลลัพธ์ compact() ของเอนจินบริบทจะไม่ส่งคืนตัวระบุตำแหน่งทรานสคริปต์อีกต่อไป ลูปลองใหม่ขณะรันไทม์จะรับเฉพาะ sessionId ตัวถัดไป
• ผลลัพธ์การผนวกทรานสคริปต์ของมิเรอร์การส่งจะไม่ส่งคืนตัวระบุตำแหน่ง ทรานสคริปต์อีกต่อไป ผู้เรียกจะได้รับ messageId ที่ผนวกแล้ว สัญญาณอัปเดตทรานสคริปต์ใช้ ขอบเขต SQLite
• ตัวช่วยฟอร์กเซสชันแม่จะส่งคืนเฉพาะ sessionId ที่ฟอร์กแล้ว การเตรียมซับเอเจนต์ จะส่งขอบเขตเอเจนต์/เซสชันลูกไปยังเอนจิน
• พารามิเตอร์ตัวรัน CLI และการเพาะประวัติใหม่จะไม่รับตัวระบุตำแหน่งทรานสคริปต์อีกต่อไป การอ่านประวัติ CLI จะระบุขอบเขตทรานสคริปต์ SQLite จาก {agentId, sessionId} และบริบทคีย์เซสชัน
• ขณะนี้ฟิกซ์เจอร์การทดสอบ CLI และตัวรันแบบฝังตัวจะเพาะและอ่านแถวทรานสคริปต์ SQLite ตามรหัสเซสชัน แทนการสมมติว่าเซสชันที่ใช้งานอยู่เป็นไฟล์ *.jsonl หรือ ส่งสตริง sqlite-transcript://... ผ่านพารามิเตอร์ขณะรันไทม์
• เหตุการณ์ตัวป้องกันผลลัพธ์เครื่องมือเซสชันจะปล่อยจากขอบเขตเซสชันที่ทราบ แม้ว่า ตัวจัดการในหน่วยความจำจะไม่มีตัวระบุตำแหน่งที่สร้างขึ้น การทดสอบจะไม่จำลองไฟล์ทรานสคริปต์ /tmp/*.jsonl ที่ใช้งานอยู่อีกต่อไป
• ขณะนี้ตัวช่วย BTW และเช็กพอยต์ Compaction จะอ่านและฟอร์กแถวทรานสคริปต์ตาม ขอบเขต SQLite เมทาดาทาเช็กพอยต์จะเก็บเฉพาะรหัสเซสชันและรหัสลีฟ/รายการ โดยจะไม่เขียนตัวระบุตำแหน่งที่สร้างขึ้นลงในเพย์โหลดเช็กพอยต์อีกต่อไป
• การค้นหาคีย์ทรานสคริปต์ของ Gateway ใช้ขอบเขตทรานสคริปต์ SQLite ที่ขอบเขต โปรโตคอล และจะไม่หาพาธจริงหรือตรวจสอบสถานะชื่อไฟล์ทรานสคริปต์อีกต่อไป
• การหมุนเวียนทรานสคริปต์สำหรับ Compaction อัตโนมัติจะเขียนแถวทรานสคริปต์ถัดไป โดยตรงผ่านที่เก็บทรานสคริปต์ SQLite แถวเซสชันจะเก็บเฉพาะข้อมูลระบุตัวตนของเซสชัน ถัดไป ไม่ใช่พาธ JSONL แบบถาวรหรือตัวระบุตำแหน่งที่คงอยู่
• Compaction ของเอนจินบริบทแบบฝังตัวใช้ตัวช่วยหมุนเวียนทรานสคริปต์ ที่ตั้งชื่อตาม SQLite การทดสอบการหมุนเวียนจะไม่สร้างพาธ JSONL ถัดไปหรือ จำลองเซสชันที่ใช้งานอยู่เป็นไฟล์อีกต่อไป
• การเก็บรักษารูปภาพขาออกแบบจัดการจะกำหนดคีย์แคชข้อความทรานสคริปต์จาก สถิติทรานสคริปต์ SQLite แทนการเรียกตรวจสอบสถานะระบบไฟล์
• ล็อกเซสชันขณะรันไทม์และช่องทาง doctor .jsonl.lock รุ่นเก่าแบบสแตนด์อโลน ถูกนำออกแล้ว
• บาร์เรลรันไทม์ Microsoft Teams และ SDK Plugin สาธารณะจะไม่ส่งออกซ้ำ ตัวช่วยล็อกไฟล์แบบเก่าอีกต่อไป พาธสถานะ Plugin แบบถาวรรองรับด้วย SQLite
• การตัดเซสชันตามอายุ/จำนวนและการล้างเซสชันแบบชัดเจนถูกนำออกแล้ว doctor เป็นเจ้าของการนำเข้ารุ่นเก่า เซสชันที่ล้าสมัยจะถูกรีเซ็ตหรือลบอย่างชัดเจน
• การตรวจสอบความสมบูรณ์ของ doctor จะไม่นับไฟล์ JSONL รุ่นเก่าเป็นทรานสคริปต์ ที่ใช้งานอยู่และถูกต้องสำหรับแถวเซสชัน SQLite อีกต่อไป สุขภาพทรานสคริปต์ที่ใช้งานอยู่ขึ้นอยู่กับ SQLite เท่านั้น ไฟล์ JSONL รุ่นเก่าจะถูกรายงานเป็นอินพุตสำหรับการย้ายข้อมูล/การล้างออร์แฟน
• doctor จะไม่ถือว่า agents/<agent>/sessions/ เป็นสถานะขณะรันไทม์ ที่จำเป็นอีกต่อไป โดยจะสแกนไดเรกทอรีนั้นเฉพาะเมื่อมีอยู่แล้วเท่านั้น เพื่อใช้เป็นอินพุต สำหรับการนำเข้ารุ่นเก่าหรือการล้างออร์แฟน
• Gateway sessions.resolve, พาธแพตช์/รีเซ็ต/Compaction ของเซสชัน, การสร้าง ซับเอเจนต์, การยกเลิกอย่างรวดเร็ว, เมทาดาทา ACP, เซสชันที่แยกจาก Heartbeat และการแพตช์ TUI จะไม่ย้ายหรือตัดคีย์เซสชันรุ่นเก่าเป็นผลข้างเคียงของงานรันไทม์ปกติอีกต่อไป
• ขณะนี้การระบุเซสชันคำสั่ง CLI จะส่งคืน agentId เจ้าของ แทน storePath และจะไม่คัดลอกแถวเซสชันหลักรุ่นเก่าระหว่างการระบุ --to หรือ --session-id ตามปกติอีกต่อไป การทำแถวหลักรุ่นเก่าให้เป็นรูปแบบมาตรฐาน เป็นหน้าที่ของ doctor เท่านั้น
• การระบุความลึกซับเอเจนต์ขณะรันไทม์จะไม่อ่าน sessions.json หรือที่เก็บเซสชัน JSON5 อีกต่อไป โดยจะอ่าน session_entries ของ SQLite ตามรหัสเอเจนต์ และเมทาดาทา ความลึก/เซสชันรุ่นเก่าจะเข้ามาได้ผ่านพาธนำเข้าของ doctor เท่านั้น
• การแทนที่เซสชันโปรไฟล์การยืนยันตัวตนจะคงอยู่ผ่านการ upsert แถว {agentId, sessionKey} โดยตรง แทนการโหลดรันไทม์ที่เก็บเซสชันรูปแบบไฟล์แบบล่าช้า
• ขณะนี้การควบคุมแบบละเอียดของการตอบกลับอัตโนมัติและตัวช่วยอัปเดตเซสชันจะอ่าน/upsert แถวเซสชัน SQLite ตามข้อมูลระบุตัวตนของเซสชัน และไม่ต้องมีพาธที่เก็บรุ่นเก่าก่อน เข้าถึงสถานะแถวที่คงอยู่อีกต่อไป
• ขณะนี้ตัวช่วยเมทาดาทาเซสชันการรันคำสั่งใช้ชื่อและพาธโมดูล ที่มุ่งเน้นรายการ พื้นผิวตัวช่วยคำสั่ง session-store แบบเก่าถูกนำออกแล้ว
• ขณะนี้การเพาะส่วนหัวบูตสแตรปและการเสริมความแข็งแกร่งของขอบเขต Compaction ด้วยตนเองจะแก้ไข แถวทรานสคริปต์ SQLite โดยตรง ผู้เรียกขณะรันไทม์จะส่งข้อมูลระบุตัวตนของเซสชัน ไม่ใช่ พาธ .jsonl ที่เขียนได้
• การเล่นซ้ำการหมุนเวียนเซสชันแบบเงียบจะคัดลอกเทิร์นล่าสุดของผู้ใช้/ผู้ช่วยตาม {agentId, sessionId} จากแถวทรานสคริปต์ SQLite โดยจะไม่รับ ตัวระบุตำแหน่งทรานสคริปต์ต้นทางหรือปลายทางอีกต่อไป
• แถวเซสชันรันไทม์ใหม่จะไม่เก็บตัวระบุตำแหน่งทรานสคริปต์อีกต่อไป ผู้เรียกใช้ {agentId, sessionId} โดยตรง คำสั่งส่งออก/ดีบักสามารถเลือกชื่อไฟล์เอาต์พุต เมื่อสร้างแถวเป็นไฟล์ได้
• ขณะนี้การเริ่มเซสชันทรานสคริปต์แบบคงอยู่ใหม่จะเปิดแถว SQLite ตาม ขอบเขตเสมอ ตัวจัดการเซสชันจะไม่นำพาธหรือตัวระบุตำแหน่งทรานสคริปต์ จากยุคไฟล์ก่อนหน้ามาใช้ซ้ำเป็นข้อมูลระบุตัวตนของเซสชันใหม่อีกต่อไป
• เซสชันทรานสคริปต์แบบคงอยู่ใช้ API openTranscriptSessionManagerForSession({agentId, sessionId}) ที่ระบุชัดเจน ฟาซาดแบบสแตติก SessionManager.create/openForSession/list/forkFromSession เดิมถูกนำออกแล้ว เพื่อไม่ให้การทดสอบและโค้ดรันไทม์สร้างการค้นพบเซสชันจากยุคไฟล์ขึ้นใหม่โดยไม่ตั้งใจ
• รันไทม์ Plugin จะไม่เปิดเผย api.runtime.agent.session.resolveTranscriptLocatorPath อีกต่อไป โค้ด Plugin ใช้ตัวช่วยแถว SQLite และค่าขอบเขต
• ขณะนี้พื้นผิว SDK session-store-runtime สาธารณะส่งออกเฉพาะตัวช่วยแถวเซสชัน และแถวทรานสคริปต์ ตัวช่วยสคีมา/พาธ/ธุรกรรม SQLite ที่มุ่งเน้น อยู่ใน sqlite-runtime ตัวช่วยเปิด/ปิด/รีเซ็ตดิบยังคงเป็นแบบภายในเท่านั้นสำหรับ การทดสอบของบุคคลที่หนึ่ง
• ขณะนี้ตัวจำแนกชื่อไฟล์วิถี/เช็กพอยต์ .jsonl รุ่นเก่าอยู่ใน โมดูลไฟล์เซสชันรุ่นเก่าของ doctor การตรวจสอบเซสชันหลักจะไม่นำเข้า ตัวช่วยอาร์ติแฟกต์ไฟล์เพื่อตัดสินรหัสเซสชัน SQLite ปกติอีกต่อไป
• การรันซับเอเจนต์แบบบล็อกของ Active Memory ใช้แถวทรานสคริปต์ SQLite แทน การสร้างไฟล์ session.jsonl ชั่วคราวหรือแบบคงอยู่ภายใต้สถานะ Plugin ตัวเลือก transcriptDir แบบเก่าถูกนำออกแล้ว
• การสร้าง slug แบบครั้งเดียวและการรันตัววางแผนเอเจนต์ระบบใช้แถวทรานสคริปต์ SQLite แทนการสร้างไฟล์ session.jsonl ชั่วคราว
• llm-task การทำงานของตัวช่วยและการแยก commitment ที่ซ่อนไว้ก็ใช้แถว transcript ใน SQLite เช่นกัน ดังนั้นเซสชันตัวช่วยสำหรับโมเดลเท่านั้นเหล่านี้จึงไม่สร้างไฟล์ transcript JSON/JSONL ชั่วคราวอีกต่อไป
• TranscriptSessionManager ตอนนี้เป็นเพียงขอบเขต transcript ของ SQLite ที่เปิดอยู่ โค้ดรันไทม์เปิดด้วย openTranscriptSessionManagerForSession({agentId, sessionId}); ขั้นตอนการสร้าง การแตกแขนง การดำเนินการต่อ การแสดงรายการ และการ fork อยู่ในตัวช่วยแถว SQLite ที่เป็นเจ้าของ แทน facade ของตัวจัดการแบบ static โค้ด Doctor/import/debug จัดการไฟล์ต้นทางแบบเดิมที่ระบุอย่างชัดเจนนอกตัวจัดการเซสชันรันไทม์
• เมธอด facade SessionManager.newSession() และ SessionManager.createBranchedSession() ที่ล้าสมัยถูกนำออกแล้ว เซสชันใหม่ และรายการสืบทอดของ transcript ถูกสร้างโดยเวิร์กโฟลว์ SQLite ที่เป็นเจ้าของ แทนการเปลี่ยนตัวจัดการที่เปิดอยู่แล้วให้กลายเป็นเซสชันถาวรอื่น
• การตัดสินใจ fork transcript แม่และการสร้าง fork ไม่รับ storePath หรือ sessionsDir อีกต่อไป แต่ใช้ขอบเขต transcript SQLite {agentId, sessionId} แทนเมทาดาทาพาธระบบไฟล์ที่เก็บไว้
• Memory-host ไม่ส่งออกตัวช่วยจำแนก transcript ตามไดเรกทอรีเซสชันที่ไม่ทำงานอีกต่อไป การกรอง transcript ตอนนี้อนุมานจากเมทาดาทาแถว SQLite ระหว่างการสร้างรายการ
• การทดสอบการส่งออกเซสชันของ Memory-host และ QMD ใช้ขอบเขต transcript ของ SQLite พาธ agents/<agentId>/sessions/*.jsonl แบบเก่ายังคงครอบคลุมเฉพาะกรณีที่การทดสอบตั้งใจพิสูจน์ความเข้ากันได้ของ doctor/import/export
• การตรวจสอบเซสชันดิบของ QA-lab ตอนนี้ใช้ sessions.list ผ่าน Gateway แทนการอ่าน agents/qa/sessions/sessions.json; ข้อเสนอแนะของ MSteams ผนวกไปยัง transcript ใน SQLite โดยตรงโดยไม่สร้างพาธ JSONL ปลอม
• รอบข้อความขาเข้าของช่องทางที่ใช้ร่วมกันตอนนี้ส่ง {agentId, sessionKey} แทน storePath แบบเดิม พาธการบันทึกของ LINE, WhatsApp, Slack, Discord, Telegram, Matrix, Signal, iMessage, BlueBubbles, Feishu, Google Chat, IRC, Nextcloud Talk, Zalo, Zalo Personal, QA Channel, Microsoft Teams, Mattermost, Synology Chat, Tlon, Twitch และ QQBot ตอนนี้อ่านเมทาดาทาเวลาอัปเดตล่าสุด และบันทึกแถวเซสชันขาเข้าผ่านข้อมูลประจำตัว SQLite
• การคงอยู่ของตัวระบุตำแหน่ง transcript ถูกนำออกจากแถวเซสชันที่ใช้งานอยู่ resolveSessionTranscriptTarget ส่งคืน agentId, sessionId และเมทาดาทาหัวข้อที่ไม่บังคับ; doctor เป็นโค้ดเดียวที่นำเข้าชื่อไฟล์ transcript แบบเดิม
• ส่วนหัว transcript ของรันไทม์เริ่มที่ SQLite เวอร์ชัน 1 การอัปเกรดรูปแบบ JSONL V1/V2/V3 เก่าอยู่เฉพาะในการนำเข้าของ doctor และปรับส่วนหัวที่นำเข้าให้เป็นเวอร์ชัน transcript SQLite ปัจจุบันก่อนจัดเก็บแถว
• ตัวป้องกันแบบยึดฐานข้อมูลเป็นหลักตอนนี้ห้าม SessionManager.listAll และ SessionManager.forkFromSession; เวิร์กโฟลว์การแสดงรายการเซสชันและ fork/restore ต้องใช้ API SQLite แบบแถว/มีขอบเขตเท่านั้น
• ตัวป้องกันยังห้ามชื่อตัวช่วยแยกวิเคราะห์ JSONL transcript แบบเดิม/ซ่อมแซมสาขาที่ใช้งานอยู่นอกโค้ด doctor/import เพื่อไม่ให้รันไทม์เพิ่มเส้นทางการย้าย transcript แบบเดิมเส้นทางที่สอง
• การทำงานของ PI แบบฝังตัวปฏิเสธแฮนเดิล transcript ที่ส่งเข้ามา โดยใช้ข้อมูลประจำตัว SQLite {agentId, sessionId} ก่อนเริ่ม worker และอีกครั้งก่อนที่ความพยายามจะเข้าถึงสถานะ transcript อินพุต /tmp/*.jsonl ที่ล้าสมัยไม่สามารถเลือกเป้าหมายการเขียนของรันไทม์ได้
• ระเบียน cache trace, เพย์โหลด Anthropic, สตรีมดิบ และไทม์ไลน์การวินิจฉัย ตอนนี้เขียนลงในแถว SQLite diagnostic_events แบบมีชนิด บันเดิลความเสถียรของ Gateway ตอนนี้เขียนลงในแถว SQLite diagnostic_stability_bundles แบบมีชนิด พาธ override JSONL เก่า diagnostics.cacheTrace.filePath, OPENCLAW_CACHE_TRACE_FILE, OPENCLAW_ANTHROPIC_PAYLOAD_LOG_FILE และ OPENCLAW_DIAGNOSTICS_TIMELINE_PATH ถูกนำออกแล้ว และการเก็บข้อมูลความเสถียรตามปกติไม่เขียนไฟล์ logs/stability/*.json อีกต่อไป
• การคงอยู่ของ Cron ตอนนี้ปรับกระทบยอดแถว SQLite cron_jobs แทน การลบ/แทรกตารางงานทั้งหมดใหม่ทุกครั้งที่บันทึก การเขียนกลับเป้าหมาย Plugin อัปเดตแถว cron ที่ตรงกันโดยตรง และเก็บสถานะ cron ของรันไทม์ไว้ในธุรกรรมฐานข้อมูลสถานะเดียวกัน
• ตัวเรียก Cron ของรันไทม์ตอนนี้ใช้คีย์ที่เก็บ cron ของ SQLite ที่เสถียร พาธ cron.store แบบเดิมเป็นเพียงอินพุตนำเข้าของ doctor; Gateway ฝั่งใช้งานจริง การบำรุงรักษางาน สถานะ ประวัติการทำงาน และพาธการเขียนกลับเป้าหมาย Telegram ใช้ resolveCronStoreKey และไม่ปรับพาธของคีย์ให้อยู่ในรูปแบบมาตรฐานอีกต่อไป ตอนนี้สถานะ Cron รายงาน storeKey แทนฟิลด์ storePath แบบเก่าที่มีรูปแบบเหมือนไฟล์
• การโหลดและจัดกำหนดการ Cron ของรันไทม์ไม่ปรับรูปแบบงานถาวรแบบเดิมให้เป็นมาตรฐานอีกต่อไป เช่น jobId, schedule.cron, atMs แบบตัวเลข, ค่าบูลีนแบบสตริง หรือ sessionTarget ที่ขาดหายไป การนำเข้าข้อมูลเดิมของ Doctor เป็นเจ้าของการซ่อมแซมเหล่านั้นก่อนแทรกแถวลงใน SQLite
• การ spawn ของ ACP ไม่แก้ไขหรือคงพาธไฟล์ transcript JSONL อีกต่อไป การตั้งค่า spawn และการผูกเธรดจะคงแถวเซสชัน SQLite โดยตรง และเก็บรหัสเซสชันไว้เป็นข้อมูลประจำตัว transcript
• API เมทาดาทาเซสชัน ACP ตอนนี้อ่าน/แสดงรายการ/upsert แถว SQLite ตาม agentId และ ไม่เปิดเผย storePath เป็นส่วนหนึ่งของสัญญารายการเซสชัน ACP อีกต่อไป
• การคำนวณการใช้งานเซสชันและการรวมการใช้งานของ Gateway ตอนนี้แก้ไข transcript ด้วย {agentId, sessionId} เท่านั้น แคชต้นทุน/การใช้งานและข้อมูลสรุปเซสชันที่ค้นพบ ไม่สร้างหรือส่งคืนสตริงตัวระบุตำแหน่ง transcript อีกต่อไป
• การผนวกแชตของ Gateway, การคงสถานะบางส่วนเมื่อยกเลิก, /sessions.send และ การเขียนสื่อ webchat ลง transcript จะผนวกโดยตรงผ่านขอบเขต transcript ของ SQLite ตัวช่วยฉีด transcript ของ Gateway ไม่รับพารามิเตอร์ transcriptLocator อีกต่อไป
• การค้นหา transcript ของ SQLite ตอนนี้แสดงเฉพาะขอบเขตและสถิติของ transcript: {agentId, sessionId, updatedAt, eventCount} ตัวช่วยความเข้ากันได้ listSqliteSessionTranscriptLocators ที่เลิกใช้แล้วและฟิลด์ต่อแถว locator ถูกนำออกแล้ว
• รันไทม์ซ่อมแซม transcript ตอนนี้เปิดเผยเฉพาะ repairTranscriptSessionStateIfNeeded({agentId, sessionId}) ตัวช่วยซ่อมแซมแบบอิงตัวระบุตำแหน่งเดิมถูกลบแล้ว; โค้ด doctor/debug อ่านพาธไฟล์ต้นทางที่ระบุชัดเจน และไม่ย้ายสตริงตัวระบุตำแหน่ง
• รันไทม์บัญชีแยกประเภทการเล่นซ้ำของ ACP ตอนนี้จัดเก็บแถวการเล่นซ้ำต่อเซสชันในฐานข้อมูลสถานะ SQLite ที่ใช้ร่วมกันแทน acp/event-ledger.json; doctor นำเข้าและลบไฟล์แบบเดิม
• ตอนนี้ตัวช่วยอ่าน transcript ของ Gateway อยู่ใน src/gateway/session-transcript-readers.ts แทนชื่อโมดูลเก่า session-utils.fs การตรวจสอบประวัติการลองใหม่สำรองตั้งชื่อตามเนื้อหา transcript ของ SQLite แทนพื้นผิวตัวช่วยไฟล์แบบเก่า
• ตัวช่วยแชตที่ฉีดเข้า Gateway และ Compaction ตอนนี้ส่งขอบเขต transcript ของ SQLite ผ่าน API ตัวช่วยภายใน แทนการตั้งชื่อค่าเป็นพาธ transcript หรือไฟล์ต้นทาง
• การตรวจจับการดำเนินการ bootstrap ต่อ ตอนนี้ตรวจสอบแถว transcript ของ SQLite ผ่าน hasCompletedBootstrapTranscriptTurn; และไม่เปิดเผยชื่อตัวช่วยที่มีรูปแบบเหมือนไฟล์อีกต่อไป
• การทดสอบ embedded-runner ตอนนี้ใช้ข้อมูลประจำตัว transcript ของ SQLite และการเปิดตัวจัดการ transcript ใหม่ ต้องมี sessionId ที่ระบุอย่างชัดเจนเสมอ
• ตัวช่วยจัดทำดัชนีหน่วยความจำตอนนี้ใช้คำศัพท์ transcript ของ SQLite ตั้งแต่ต้นจนจบ: host ส่งออก listSessionTranscriptScopesForAgent และ sessionTranscriptKeyForScope, คิวซิงค์แบบเจาะจงใช้ sessionTranscripts, ผลลัพธ์การค้นหาเซสชันสาธารณะเปิดเผยพาธทึบแสง transcript:<agent>:<session>, และคีย์ต้นทาง DB ภายในคือ session:<session> ภายใต้ source_kind='sessions' แทนพาธไฟล์ปลอม
• ตัวช่วย persistent-dedupe ทั่วไปของ SDK สำหรับ Plugin ไม่เปิดเผยตัวเลือกที่มีรูปแบบเหมือนไฟล์อีกต่อไป ผู้เรียกให้คีย์ขอบเขต SQLite และแถว dedupe ถาวรอยู่ในสถานะ Plugin ที่ใช้ร่วมกัน
• โทเค็น SSO ของ Microsoft Teams ย้ายจากไฟล์ JSON ที่ล็อกไว้ไปยังสถานะ Plugin ใน SQLite Doctor นำเข้า msteams-sso-tokens.json, สร้างคีย์โทเค็น SSO มาตรฐานใหม่จากเพย์โหลด และลบไฟล์ต้นทาง โทเค็น OAuth ที่มอบหมายยังคงอยู่บนขอบเขตไฟล์ข้อมูลประจำตัวส่วนตัวเดิม
• สถานะแคชการซิงค์ Matrix ย้ายจาก bot-storage.json ไปยังสถานะ Plugin ใน SQLite Doctor นำเข้าเพย์โหลดการซิงค์ดิบหรือแบบห่อหุ้มเดิม และลบไฟล์ต้นทาง ไคลเอนต์อะแดปเตอร์ Matrix ที่ใช้งานอยู่และ QA Lab Matrix ส่งไดเรกทอรีรากของที่เก็บการซิงค์ SQLite ไม่ใช่พาธ sync-store.json หรือ bot-storage.json ปลอม
• สถานะการย้ายการเข้ารหัสแบบเดิมของ Matrix ย้ายจาก legacy-crypto-migration.json ไปยังสถานะ Plugin ใน SQLite Doctor นำเข้า ไฟล์สถานะเก่า; สแนปช็อต IndexedDB ของ Matrix SDK ย้ายจาก crypto-idb-snapshot.json ไปยัง blob ของ Plugin ใน SQLite คีย์การกู้คืนและข้อมูลประจำตัวของ Matrix เป็นแถวสถานะ Plugin ใน SQLite; ไฟล์ JSON เก่าของรายการเหล่านี้เป็นเพียงอินพุตการย้ายของ doctor
• บันทึกกิจกรรมของ Memory Wiki ตอนนี้ใช้สถานะ Plugin ใน SQLite แทน .openclaw-wiki/log.jsonl ผู้ให้บริการย้ายข้อมูล Memory Wiki นำเข้า บันทึก JSONL เก่า; markdown ของวิกิและเนื้อหา vault ของผู้ใช้ยังคงมีไฟล์รองรับเป็นเนื้อหาของ workspace
• Memory Wiki ไม่สร้าง .openclaw-wiki/state.json หรือไดเรกทอรี .openclaw-wiki/locks ที่ไม่ได้ใช้อีกต่อไป ผู้ให้บริการย้ายข้อมูลจะลบไฟล์เมทาดาทา Plugin ที่เลิกใช้เหล่านั้น หาก vault เก่ายังคงมีไฟล์ดังกล่าว
• รายการตรวจสอบของ system-agent ตอนนี้ใช้สถานะ Plugin หลักใน SQLite แทน audit/crestodian.jsonl Doctor นำเข้าบันทึกการตรวจสอบ JSONL แบบเดิมและลบออกหลังจากนำเข้าสำเร็จ
• รายการตรวจสอบการเขียน/สังเกต config ตอนนี้ใช้สถานะ Plugin หลักใน SQLite แทน logs/config-audit.jsonl Doctor นำเข้าบันทึกการตรวจสอบ JSONL แบบเดิมและลบออกหลังจากนำเข้าสำเร็จ
• แอปคู่หู macOS ไม่เขียน sidecar logs/config-audit.jsonl หรือ logs/config-health.json ภายในแอปขณะแก้ไข openclaw.json อีกต่อไป ไฟล์ config ยังคงมีไฟล์รองรับ สแนปช็อตการกู้คืนยังคงอยู่ข้างไฟล์ config และสถานะการตรวจสอบ/สุขภาพของ config แบบถาวรอยู่ในที่เก็บ SQLite ของ Gateway
• การอนุมัติที่รอดำเนินการสำหรับการกู้คืนของ system-agent ตอนนี้ใช้สถานะ Plugin หลักใน SQLite แทน crestodian/rescue-pending/*.json หรือ openclaw/rescue-pending/*.json ความสามารถด้านความปลอดภัยอายุสั้นเหล่านี้จะไม่ถูกนำเข้า; doctor ละทิ้งไดเรกทอรีที่เลิกใช้ทั้งสอง เพื่อไม่ให้การอัปเกรดเปิดใช้งานการเขียนที่ล้าสมัยอีกครั้ง
• สถานะ arm ชั่วคราวของ Phone Control ตอนนี้ใช้สถานะ Plugin ใน SQLite แทน plugins/phone-control/armed.json Doctor นำเข้าไฟล์ armed-state แบบเดิม ไปยัง namespace phone-control/arm-state และลบไฟล์
• Doctor ไม่ซ่อมแซม transcript JSONL ในตำแหน่งเดิมหรือสร้างไฟล์ JSONL สำรองอีกต่อไป แต่จะนำเข้าสาขาที่ใช้งานอยู่ไปยัง SQLite และลบต้นทางแบบเดิม
• การค้นหา transcript ของ hook session-memory ใช้การอ่าน SQLite เฉพาะขอบเขต {agentId, sessionId} ตัวช่วยไม่รับหรืออนุมานตัวระบุตำแหน่ง transcript, การอ่านไฟล์แบบเดิม หรือตัวเลือกการเขียนไฟล์ใหม่อีกต่อไป
• การผูกการสนทนาของ Codex app-server ตอนนี้กำหนดคีย์สถานะ Plugin ใน SQLite ตามคีย์เซสชัน OpenClaw หรือขอบเขต {agentId, sessionId} ที่ระบุชัดเจน และต้องไม่เก็บการผูกสำรองที่อิงพาธ transcript
• การอ่านประวัติที่ทำสำเนาของ Codex app-server ใช้เฉพาะขอบเขต transcript ของ SQLite; และต้องไม่กู้คืนข้อมูลประจำตัวจากพาธไฟล์ transcript
• พาธการจัดลำดับบทบาทและการรีเซ็ต Compaction ไม่ unlink ไฟล์ transcript เก่าอีกต่อไป; การรีเซ็ตจะหมุนเฉพาะแถวเซสชัน SQLite และข้อมูลประจำตัว transcript
• การตอบกลับการรีเซ็ตและ checkpoint ของ Gateway ส่งคืนแถวเซสชันที่สะอาดพร้อมรหัสเซสชัน และไม่สร้างตัวระบุตำแหน่ง transcript ของ SQLite สำหรับไคลเอนต์อีกต่อไป
• Dreaming ของ memory-core ไม่ล้างแถวเซสชันโดยตรวจหาไฟล์ JSONL ที่หายไปอีกต่อไป การล้างข้อมูล subagent ดำเนินการผ่าน API รันไทม์เซสชันแทนการตรวจสอบการมีอยู่ในระบบไฟล์ การทดสอบการนำเข้า transcript จะป้อนแถว SQLite โดยตรงแทนการสร้าง fixture agents/<id>/sessions หรือตัวยึดตำแหน่ง
• การจัดทำดัชนี transcript ของหน่วยความจำอาจเปิดเผย transcript:<agentId>:<sessionId> เป็น พาธผลลัพธ์การค้นหาเสมือนสำหรับตัวช่วยการอ้างอิง/การอ่าน ต้นทางดัชนีถาวรเป็นแบบเชิงสัมพันธ์ (source_kind='sessions', source_key='session:<sessionId>', session_id=<sessionId>) ดังนั้นค่านี้จึงไม่ใช่ตัวระบุตำแหน่งทรานสคริปต์ของรันไทม์ ไม่ใช่พาธระบบไฟล์ และต้องไม่ส่งกลับไปยัง API รันไทม์ของเซสชันโดยเด็ดขาด
• สถานะหน่วยความจำของ Gateway doctor อ่านจำนวนการเรียกคืนระยะสั้นและสัญญาณเฟส จากแถวสถานะ Plugin ใน SQLite แทน memory/.dreams/*.json; ขณะนี้เอาต์พุตของ CLI และ doctor ระบุที่จัดเก็บนั้นว่าเป็นที่จัดเก็บ SQLite ไม่ใช่พาธ
• รันไทม์ memory-core, สถานะ CLI, เมธอด Gateway doctor และ facade ของ SDK สำหรับ Plugin จะไม่ตรวจสอบหรือเก็บถาวรไฟล์ .dreams/session-corpus แบบเดิมอีกต่อไป ไฟล์เหล่านั้นเป็นเพียงอินพุตสำหรับการย้ายข้อมูล โดย doctor จะนำเข้าไฟล์เหล่านั้นไปยัง SQLite และ ลบต้นทางหลังจากตรวจสอบแล้ว ขณะนี้แถวหลักฐานการนำเข้าเซสชันที่ใช้งานอยู่ ใช้พาธ SQLite เสมือน memory/session-ingestion/<day>.txt; รันไทม์ จะไม่เขียนหรืออนุมานสถานะจาก .dreams/session-corpus โดยเด็ดขาด
• อาร์ติแฟกต์สาธารณะของ memory-core เปิดเผยเหตุการณ์โฮสต์ SQLite เป็นอาร์ติแฟกต์ JSON เสมือน memory/events/memory-host-events.json; โดยจะไม่ใช้พาธต้นทาง .dreams/events.jsonl แบบเดิมซ้ำอีกต่อไป
• ขณะนี้รีจิสทรีคอนเทนเนอร์/เบราว์เซอร์ของแซนด์บ็อกซ์ใช้ตาราง SQLite sandbox_registry_entries ที่ใช้ร่วมกัน โดยมีคอลัมน์แบบมีชนิดสำหรับเซสชัน อิมเมจ การประทับเวลา แบ็กเอนด์/การกำหนดค่า และพอร์ตเบราว์เซอร์ Doctor นำเข้าไฟล์รีจิสทรี JSON แบบรวมไฟล์เดียวและ แบบแบ่งชาร์ดที่เป็นระบบเดิม แล้วลบต้นทางที่นำเข้าสำเร็จ การอ่านของรันไทม์ใช้ คอลัมน์แถวแบบมีชนิดเป็นแหล่งข้อมูลจริง ส่วน entry_json เป็นเพียงสำเนา สำหรับเล่นซ้ำ/ดีบัก
• ขณะนี้ข้อผูกพันใช้ตาราง commitments แบบมีชนิดที่ใช้ร่วมกัน แทน บล็อบ JSON ของที่จัดเก็บทั้งหมด รันไทม์ใช้คิวรีที่มีดัชนีสำหรับขอบเขต หน้าต่างการส่ง ขีดจำกัดแบบเลื่อน สถานะ และความพยายาม รวมถึงทรานแซกชัน SQLite แบบซิงโครนัส ส่วน record_json เป็นเพียงสำเนาสำหรับเล่นซ้ำ/ดีบัก การซ่อมแซมโดย doctor ที่สั่งอย่างชัดเจนจะตรวจสอบ commitments.json แบบเดิมทั้งหมด เก็บแถว SQLite ที่ใหม่กว่าไว้ ตรวจสอบ ผลลัพธ์ และหลังจากนั้นจึงลบต้นทางที่ไม่เปลี่ยนแปลง รันไทม์จะไม่อ่านหรือ เขียนไฟล์ที่เลิกใช้แล้วโดยเด็ดขาด
• ขณะนี้การสมัครรับ Web Push และข้อมูลประจำตัว VAPID ที่สร้างขึ้นใช้แถว web_push_subscriptions และ web_push_vapid_keys แบบมีชนิดที่ใช้ร่วมกัน การลงทะเบียนของรันไทม์ การล้างข้อมูลที่หมดอายุ และการสร้างคีย์เมื่อใช้งานครั้งแรกใช้ทรานแซกชัน SQLite ระดับแถว การซ่อมแซมโดย Doctor ที่สั่งอย่างชัดเจนจะตรวจสอบที่จัดเก็บ JSON ที่เลิกใช้แล้วทั้งสองรายการ อ้างสิทธิ์รายการเหล่านั้นก่อนเขียน SQLite นำเข้าแบบอะตอมมิก ปฏิเสธ ข้อมูลประจำตัว VAPID ที่ขัดแย้งกัน ตรวจสอบผลลัพธ์ และหลังจากนั้นจึงลบ การอ้างสิทธิ์ Doctor จะถือล็อกการบำรุงรักษาไดเรกทอรีสถานะตลอดการ นำเข้า เพื่อไม่ให้ Gateway รุ่นเก่าสร้างไฟล์ที่เลิกใช้แล้วขึ้นมาใหม่ การลงทะเบียน การส่ง การลบ และการแก้ไขคีย์จะปฏิเสธการทำงานจนกว่า Doctor จะแก้ไข ต้นทางแบบเดิมที่ค้างอยู่หรือการอ้างสิทธิ์ที่ถูกขัดจังหวะ
• ข้อกำหนดงาน Cron, สถานะกำหนดการ และประวัติการเรียกใช้ไม่มีตัวเขียน หรือตัวอ่าน JSON ในรันไทม์อีกต่อไป รันไทม์ใช้แถว cron_jobs ที่มีคอลัมน์แบบมีชนิดสำหรับกำหนดการ เพย์โหลด การส่ง การแจ้งเตือนความล้มเหลว เซสชัน สถานะ และสถานะรันไทม์ รวมถึง รายละเอียด task_runs ที่ Cron เป็นเจ้าของ สำหรับการวินิจฉัย การส่ง เซสชัน/การเรียกใช้ โมเดล และยอดรวมโทเค็น job_json เป็นเพียงสำเนาสำหรับเล่นซ้ำ/ดีบัก ส่วน state_json เก็บ การวินิจฉัยรันไทม์แบบซ้อนที่ยังไม่มีฟิลด์คิวรีเส้นทางด่วน ขณะที่รันไทม์ เติมสถานะฟิลด์เส้นทางด่วนกลับจากคอลัมน์แบบมีชนิด Doctor นำเข้า ไฟล์ jobs.json, jobs-state.json และ runs/*.jsonl แบบเดิม แล้วลบ ต้นทางที่นำเข้า การเขียนค่ากลับของเป้าหมาย Plugin จะอัปเดตแถว cron_jobs ที่ตรงกัน แทนการโหลดและแทนที่ที่จัดเก็บ Cron ทั้งหมด
• การเริ่มต้น Gateway จะไม่สนใจมาร์กเกอร์ notify: true แบบเดิมในการฉายภาพ รันไทม์ Doctor อ่าน cron.webhook ดิบที่เลิกใช้แล้วเฉพาะระหว่างแปล มาร์กเกอร์เหล่านั้นเป็นการส่งผ่าน SQLite อย่างชัดเจน จากนั้นจึงลบคีย์การกำหนดค่า
• ขณะนี้คิวการส่งขาออกและการส่งของเซสชันจัดเก็บสถานะคิว ชนิดรายการ คีย์เซสชัน ช่องทาง เป้าหมาย รหัสบัญชี จำนวนการลองใหม่ ความพยายาม/ข้อผิดพลาดล่าสุด สถานะการกู้คืน และมาร์กเกอร์การส่งของแพลตฟอร์มเป็นคอลัมน์แบบมีชนิดในตาราง delivery_queue_entries ที่ใช้ร่วมกัน การกู้คืนของรันไทม์อ่านฟิลด์เส้นทางด่วนเหล่านั้นจาก คอลัมน์แบบมีชนิด และการเปลี่ยนแปลงสำหรับการลองใหม่/กู้คืนจะอัปเดตคอลัมน์เหล่านั้นโดยตรง โดยไม่เขียน JSON สำหรับเล่นซ้ำใหม่ เพย์โหลด JSON ทั้งหมดยังคงอยู่เพียงในฐานะ บล็อบสำหรับเล่นซ้ำ/ดีบักสำหรับเนื้อหาข้อความและข้อมูลเล่นซ้ำที่ไม่ได้ใช้บ่อยอื่น ๆ
• ขณะนี้ระเบียนอิมเมจขาออกที่มีการจัดการใช้แถว managed_outgoing_image_records แบบมีชนิดที่ใช้ร่วมกัน รันไทม์อ่านเฉพาะคอลัมน์แบบมีชนิด ส่วน คอลัมน์ JSON เป็นสำเนาสำหรับเล่นซ้ำ/ดีบัก ไบต์อิมเมจต้นฉบับยังคงเป็น อาร์ติแฟกต์ไฟล์แนบที่มีชื่อในไดเรกทอรีสื่อที่มีการจัดการ
• ขณะนี้ค่ากำหนดตัวเลือกโมเดลของ Discord, แฮชการปรับใช้คำสั่ง และการผูกเธรด ใช้สถานะ Plugin ของ SQLite ที่ใช้ร่วมกัน แผนการนำเข้า JSON แบบเดิมของรายการเหล่านี้อยู่ใน พื้นผิวการย้ายข้อมูลสำหรับการตั้งค่า/doctor ของ Plugin Discord ไม่ใช่ในโค้ดการย้ายข้อมูลหลัก
• ตัวตรวจจับการนำเข้าระบบเดิมของ Plugin ใช้โมดูลที่ตั้งชื่อตาม doctor เช่น doctor-legacy-state.ts หรือ doctor-state-imports.ts; โมดูลรันไทม์ช่องทางปกติ ต้องไม่นำเข้าตัวตรวจจับ JSON แบบเดิม
• ขณะนี้เคอร์เซอร์การติดตามข้อมูลย้อนหลังและมาร์กเกอร์ป้องกันข้อมูลขาเข้าซ้ำของ BlueBubbles ใช้สถานะ Plugin ของ SQLite ที่ใช้ร่วมกัน แผนการนำเข้า JSON แบบเดิมของรายการเหล่านี้อยู่ในพื้นผิวการย้ายข้อมูล สำหรับการตั้งค่า/doctor ของ Plugin BlueBubbles ไม่ใช่ในโค้ดการย้ายข้อมูลหลัก
• ขณะนี้ออฟเซ็ตการอัปเดต แถวแคชสติกเกอร์ แถวแคชข้อความที่ส่ง แถวแคชชื่อหัวข้อ และการผูกเธรดของ Telegram ใช้สถานะ Plugin ของ SQLite ที่ใช้ร่วมกัน แผนการนำเข้า JSON แบบเดิมของรายการเหล่านี้อยู่ในพื้นผิวการย้ายข้อมูล สำหรับการตั้งค่า/doctor ของ Plugin Telegram ไม่ใช่ในโค้ดการย้ายข้อมูลหลัก
• ขณะนี้เคอร์เซอร์การติดตามข้อมูลย้อนหลัง การแมปรหัสย่อการตอบกลับ และแถวป้องกันเอคโคข้อความที่ส่งซ้ำ ของ iMessage ใช้สถานะ Plugin ของ SQLite ที่ใช้ร่วมกัน ไฟล์เก่า imessage/catchup/*.json, imessage/reply-cache.jsonl และ imessage/sent-echoes.jsonl เป็นเพียงอินพุตสำหรับ doctor
• ขณะนี้แถวป้องกันข้อความซ้ำของ Feishu ใช้ระบบป้องกันข้อมูลซ้ำแบบอ้างสิทธิ์ได้ของแกนหลัก (เนมสเปซ feishu.dedup.* ในสถานะ Plugin ของ SQLite ที่ใช้ร่วมกัน) แทน ไฟล์ feishu/dedup/*.json หรือที่จัดเก็บ dedup.* ที่สร้างขึ้นเองและเลิกใช้แล้ว โดย ไม่มีการนำเข้าระบบเดิม เนื่องจากแคชป้องกันการเล่นซ้ำจะสร้างใหม่หลังการอัปเกรด
• ขณะนี้การสนทนา แบบสำรวจ บัฟเฟอร์อัปโหลดที่ค้างอยู่ และข้อมูลการเรียนรู้จากข้อเสนอแนะ ของ Microsoft Teams ใช้ตารางสถานะ/บล็อบ Plugin ของ SQLite ที่ใช้ร่วมกัน พาธการอัปโหลดที่ค้างอยู่ ใช้ plugin_blob_entries เพื่อให้บัฟเฟอร์สื่อจัดเก็บเป็น SQLite BLOB แทน JSON แบบ base64 ขณะนี้ชื่อเฮลเปอร์รันไทม์ใช้การตั้งชื่อตาม SQLite/สถานะ แทนการตั้งชื่อตามที่จัดเก็บไฟล์ *-fs และชิมเก่า storePath ถูกนำออก จากที่จัดเก็บเหล่านี้แล้ว แผนการนำเข้า JSON แบบเดิมอยู่ในพื้นผิวการย้ายข้อมูล สำหรับการตั้งค่า/doctor ของ Plugin Microsoft Teams
• ขณะนี้สื่อขาออกที่โฮสต์โดย Zalo ใช้ plugin_blob_entries ของ SQLite ที่ใช้ร่วมกัน แทนไซด์คาร์ชั่วคราว JSON/bin openclaw-zalo-outbound-media
• ขณะนี้ HTML และเมทาดาทาของตัวดูส่วนต่างใช้ plugin_blob_entries ของ SQLite ที่ใช้ร่วมกัน แทนไฟล์ชั่วคราว meta.json/viewer.html HTML ของตัวดูถูกจัดเก็บเป็น บล็อบ gzip และจะคงอยู่เฉพาะแฮชโทเค็น URL เอาต์พุต PNG/PDF ที่เรนเดอร์แล้ว ยังคงเป็นไฟล์ชั่วคราวที่สร้างขึ้น เนื่องจากการส่งผ่านช่องทางยังต้องใช้พาธไฟล์ เมทาดาทาการหมดอายุของไฟล์เหล่านั้นอยู่ภายใต้การจัดการของ SQLite โดยไม่มีไซด์คาร์ JSON
• ขณะนี้เอกสารที่มีการจัดการของ Canvas ใช้ plugin_blob_entries ของ SQLite ที่ใช้ร่วมกัน แทน ไดเรกทอรีเริ่มต้น state/canvas/documents โฮสต์ Canvas ให้บริการบล็อบเหล่านั้น โดยตรง โดยจะสร้างไฟล์ภายในเครื่องเฉพาะสำหรับเนื้อหาของผู้ปฏิบัติงาน host.root ที่ระบุอย่างชัดเจน หรือการสร้างไฟล์ชั่วคราวเมื่อเครื่องมืออ่านสื่อปลายทาง ต้องใช้พาธ
• ขณะนี้การตัดสินใจตรวจสอบ File Transfer ใช้ plugin_state_entries ของ SQLite ที่ใช้ร่วมกัน แทนบันทึกรันไทม์ audit/file-transfer.jsonl ที่ไม่มีขอบเขตจำกัด Doctor นำเข้าไฟล์ตรวจสอบ JSONL แบบเดิมเข้าสู่สถานะ Plugin และลบต้นทาง หลังจากนำเข้าอย่างสมบูรณ์
• ขณะนี้ลีสกระบวนการ ACPX และข้อมูลประจำตัวอินสแตนซ์ Gateway ใช้สถานะ Plugin ของ SQLite ที่ใช้ร่วมกัน Doctor นำเข้าไฟล์ gateway-instance-id แบบเดิมเข้าสู่สถานะ Plugin และลบต้นทาง
• สคริปต์ตัวห่อหุ้มที่ ACPX สร้างขึ้นและโฮม Codex ที่แยกออกมาเป็นการสร้างไฟล์ ชั่วคราวภายใต้รูทชั่วคราวของ OpenClaw ไม่ใช่สถานะถาวรของ OpenClaw ระเบียน รันไทม์ ACPX แบบถาวรคือแถวลีสและอินสแตนซ์ Gateway ใน SQLite พื้นผิวการกำหนดค่า ACPX เก่า stateDir ถูกนำออก เนื่องจากไม่มีการเขียนสถานะรันไทม์ ที่นั่นอีกต่อไป
• ขณะนี้ไฟล์แนบสื่อของ Gateway ใช้ตาราง SQLite media_blobs ที่ใช้ร่วมกันเป็น ที่จัดเก็บไบต์หลัก พาธภายในเครื่องที่ส่งคืนไปยังพื้นผิวความเข้ากันได้ของช่องทางและ แซนด์บ็อกซ์เป็นไฟล์ชั่วคราวที่สร้างจากแถวฐานข้อมูล ไม่ใช่ ที่จัดเก็บสื่อถาวร รายการอนุญาตสื่อของรันไทม์จะไม่รวมรูท $OPENCLAW_STATE_DIR/media แบบเดิมหรือ media ของไดเรกทอรีการกำหนดค่าอีกต่อไป ไดเรกทอรีเหล่านั้นเป็น เพียงต้นทางสำหรับการนำเข้าของ doctor
• การเติมคำสั่งเชลล์จะไม่เขียนไฟล์แคช $OPENCLAW_STATE_DIR/completions/* อีกต่อไป พาธการติดตั้ง doctor การอัปเดต และการทดสอบควันของรีลีส ใช้เอาต์พุตการเติมคำสั่งที่สร้างขึ้นหรือการโหลดจากโปรไฟล์ แทนไฟล์แคช การเติมคำสั่งแบบถาวร
• ขณะนี้พื้นที่พักการอัปโหลด Skills ของ Gateway ใช้แถว skill_uploads และ skill_upload_chunks ที่ใช้ร่วมกัน แต่ละส่วนยังคงทำทรานแซกชันแยกกันระหว่าง การอัปโหลด จากนั้นเมื่อคอมมิต ระบบจะประกอบเป็น BLOB อาร์ไคฟ์เดียวที่ผ่านการตรวจสอบและลบแถว ของส่วนต่าง ๆ ตัวติดตั้งจะได้รับเฉพาะพาธอาร์ไคฟ์ชั่วคราวที่สร้างขึ้นระหว่าง การติดตั้งเท่านั้น Doctor จะทิ้งโครงสร้างพื้นที่พักในระบบไฟล์อายุหนึ่งชั่วโมงที่เลิกใช้แล้ว แทนการนำเข้าการอัปโหลดชั่วคราว
• ไฟล์แนบแบบอินไลน์ของเอเจนต์ย่อยจะไม่สร้างไฟล์ภายใต้ .openclaw/attachments/* ของเวิร์กสเปซอีกต่อไป พาธการสร้างจะเตรียมรายการเมล็ด VFS ของ SQLite การเรียกใช้แบบอินไลน์จะใส่รายการเหล่านั้นลงในเนมสเปซพื้นที่ชั่วคราวของรันไทม์ต่อเอเจนต์ และเครื่องมือที่ใช้ดิสก์จะวางพื้นที่ชั่วคราว SQLite นั้นทับสำหรับพาธไฟล์แนบ คอลัมน์รีจิสทรีไดเรกทอรีไฟล์แนบสำหรับการเรียกใช้เอเจนต์ย่อยและฮุกล้างข้อมูลแบบเก่าถูกนำออกแล้ว
• การเติมข้อมูลอิมเมจของ CLI จะไม่ดูแลไฟล์แคช openclaw-cli-images แบบคงที่อีกต่อไป แบ็กเอนด์ CLI ภายนอกยังคงได้รับพาธไฟล์ แต่พาธเหล่านั้นเป็น ไฟล์ชั่วคราวที่สร้างต่อการเรียกใช้พร้อมการล้างข้อมูล
• ขณะนี้การวินิจฉัยการติดตามแคช การวินิจฉัยเพย์โหลด Anthropic สตรีมโมเดลดิบ เหตุการณ์ไทม์ไลน์การวินิจฉัย และชุดข้อมูลเสถียรภาพของ Gateway เขียนแถว SQLite แทนไฟล์ logs/*.jsonl หรือ logs/stability/*.json แฟล็กและตัวแปรสภาพแวดล้อมสำหรับเขียนทับพาธรันไทม์ถูกนำออกแล้ว คำสั่งส่งออก/ดีบัก สามารถสร้างไฟล์จากแถวฐานข้อมูลอย่างชัดเจน
• แอปคู่หู macOS ไม่มีตัวเขียน diagnostics.jsonl แบบเลื่อนอีกต่อไป บันทึก ของแอปไปยังระบบบันทึกแบบรวม และการวินิจฉัย Gateway แบบถาวรยังคงใช้ SQLite
• ขณะนี้รายการระเบียนผู้พิทักษ์พอร์ตของ macOS ใช้แถว macos_port_guardian_records แบบมีชนิดของ SQLite ที่ใช้ร่วมกัน แทนไฟล์ JSON ใน Application Support หรือบล็อบซิงเกิลตันแบบทึบ โปรไฟล์แอป macOS ทั้งหมดใช้ฐานข้อมูลเนทีฟส่วนกลางของโฮสต์ เดียวกัน เนื่องจากต้องประสานงานพอร์ตภายในเครื่อง การดำเนินการกับบัญชีแยกประเภททุกครั้ง จะถูกบล็อกขณะที่สำเนาแอปรุ่นเก่าที่ยังเขียน JSON กำลังทำงาน การย้ายข้อมูลจะเข้าร่วมโปรโตคอล ล็อกไฟล์แบบเสถียรของบัญชีแยกประเภทเดิมเฉพาะเพื่อสร้างสแนปช็อตและตรวจสอบต้นทางซ้ำ ในภายหลัง ระบบจะแก้ไขทุกแถวแบบเดิมจากข้อเท็จจริงของคำสั่งสดและเวลาเริ่มกระบวนการ โดยไม่ถือล็อกนั้น จากนั้นอ่านแถว SQLite ที่เชื่อถือได้อีกครั้ง ใช้แผน ตรวจสอบใบรับทุกรายการ และลบต้นทาง การลองลบใหม่จะวางแผนแถวที่ขาดหายอีกครั้ง เพื่อไม่ให้ใบรับเก่าที่เลิกใช้แล้วฟื้นกลับมา ล็อกมีอายุสั้น เพื่อไม่ให้ตัวเขียนรุ่นเก่าค้างหลังจาก SSH สร้างกระบวนการแล้ว การเปลี่ยนผ่าน เป็นแบบทางเดียวโดยเจตนา กล่าวคือรันไทม์ในสภาวะปกติจะไม่อ่าน ฉายภาพ หรือเขียน JSON โดยเด็ดขาด และการย้อนกลับไปยังบิลด์ที่ใช้เฉพาะ JSON จะไม่รักษาใบรับ SQLite ที่ใหม่กว่า
• ขณะนี้ล็อกซิงเกิลตันของ Gateway ใช้แถว state_leases แบบมีชนิดของ SQLite ที่ใช้ร่วมกัน ภายใต้ ขอบเขต gateway_locks แทนไฟล์ล็อกในไดเรกทอรีชั่วคราว เอกสารการแก้ไขปัญหา Fly และ OAuth ชี้ไปยังลีส SQLite/ล็อกการรีเฟรชการรับรองความถูกต้อง แทน การล้างไฟล์ล็อกที่ล้าสมัย
• ขณะนี้สถานะ sentinel สำหรับการรีสตาร์ต Gateway ใช้แถว SQLite แบบใช้ร่วมกันที่มีชนิดข้อมูล gateway_restart_sentinel แทน restart-sentinel.json; รันไทม์ อ่านชนิด สถานะ การกำหนดเส้นทาง ข้อความ การดำเนินการต่อ และสถิติของ sentinel จาก คอลัมน์ที่มีชนิดข้อมูล คอลัมน์เหล่านั้นเป็นข้อมูลอ้างอิงหลัก; payload_json เป็นเพียง เงาสำหรับการเล่นซ้ำ/ดีบัก เส้นทางการอ่าน เขียน และล้างข้อมูลของรันไทม์ใช้ SQLite เท่านั้น โมดูลย้ายสถานะแบบจำกัดขอบเขตหนึ่งโมดูลทำงานระหว่างการเริ่มต้นและ Doctor เพื่อนำเข้า sentinel หลังการอัปเดตรุ่นเก่าที่ผ่านการตรวจสอบก่อนการกู้คืนจากการรีสตาร์ตตามปกติ ตรวจสอบ แถวที่มีชนิดข้อมูล และลบไฟล์ต้นทาง ไม่มีโมดูลรันไทม์ในสภาวะคงตัวใด อ่าน เขียน หรือล้างไฟล์เดิม
• ขณะนี้เจตนาการรีสตาร์ต Gateway และสถานะการส่งมอบให้ supervisor ใช้แถว SQLite แบบใช้ร่วมกันที่มีชนิดข้อมูล gateway_restart_intent และ gateway_restart_handoff แทน sidecar gateway-restart-intent.json และ gateway-supervisor-restart-handoff.json
• ขณะนี้การประสานงาน singleton ของ Gateway ใช้แถว state_leases ที่มีชนิดข้อมูลภายใต้ gateway_locks แทนการเขียนไฟล์ gateway.<hash>.lock แถว lease เป็นเจ้าของข้อมูลเจ้าของล็อก เวลาหมดอายุ heartbeat และเพย์โหลดดีบัก; SQLite เป็นเจ้าของ ขอบเขตการรับ/ปล่อยแบบอะตอม ตัวเลือกไดเรกทอรีล็อกไฟล์ที่เลิกใช้แล้ว ถูกนำออก; การทดสอบใช้ข้อมูลประจำตัวของแถว SQLite โดยตรง
• ลบตัวช่วยรายงานการใช้งาน Cron รุ่นเก่าที่ไม่มีการอ้างอิงและสแกนไฟล์ cron/runs/*.jsonl แล้ว รายงานประวัติการทำงานของ Cron อ่านแถว task_runs ที่ Cron เป็นเจ้าของ
• ขณะนี้การกู้คืนจากการรีสตาร์ตของเซสชันหลักค้นหาเอเจนต์ที่เป็นไปได้ผ่านรีจิสทรี SQLite agent_databases แทนการสแกนไดเรกทอรี agents/*/sessions
• ขณะนี้การกู้คืนความเสียหายของเซสชัน Gemini ลบเฉพาะแถวเซสชันใน SQLite; ไม่ต้องใช้เกต storePath เดิมอีกต่อไป และไม่พยายามยกเลิกการเชื่อมโยง พาธ JSONL ของทรานสคริปต์ที่ได้จากการคำนวณ
• ขณะนี้การจัดการการแทนที่พาธถือว่าค่าสภาพแวดล้อมแบบลิเทอรัล undefined/null ไม่ได้ตั้งค่า เพื่อป้องกันการสร้างฐานข้อมูล undefined/state/*.sqlite ที่รากรีโพโดยไม่ตั้งใจ ระหว่างการทดสอบหรือการส่งมอบผ่านเชลล์
• ขณะนี้ลายนิ้วมือสถานะความสมบูรณ์ของการกำหนดค่าใช้แถว SQLite แบบใช้ร่วมกันที่มีชนิดข้อมูล config_health_entries แทน logs/config-health.json ทำให้ไฟล์การกำหนดค่าปกติเป็น เอกสารการกำหนดค่าที่ไม่ใช่ข้อมูลประจำตัวเพียงรายการเดียว แอปคู่หู macOS เก็บเฉพาะ สถานะความสมบูรณ์ภายในโปรเซสและไม่สร้าง sidecar JSON เดิมขึ้นใหม่
• รันไทม์โปรไฟล์การยืนยันตัวตนไม่นำเข้าหรือเขียนไฟล์ JSON ข้อมูลประจำตัวอีกต่อไป ที่จัดเก็บข้อมูลประจำตัวหลักคือ SQLite; auth-profiles.json, auth.json ต่อเอเจนต์ และ credentials/oauth.json แบบใช้ร่วมกันเป็นอินพุตการย้ายข้อมูลของ doctor ซึ่งจะถูกลบหลังการนำเข้า
• ขณะนี้การทดสอบการบันทึก/สถานะโปรไฟล์การยืนยันตัวตนตรวจสอบตารางการยืนยันตัวตน SQLite ที่มีชนิดข้อมูลโดยตรง และใช้ชื่อไฟล์โปรไฟล์การยืนยันตัวตนเดิมเฉพาะเป็นอินพุตการย้ายข้อมูลของ doctor
• openclaw secrets apply ล้างเฉพาะไฟล์การกำหนดค่า ไฟล์ env และที่จัดเก็บ โปรไฟล์การยืนยันตัวตน SQLite เท่านั้น ไม่รวมตรรกะความเข้ากันได้ที่แก้ไข auth.json ต่อเอเจนต์ที่เลิกใช้แล้วอีกต่อไป; doctor เป็นเจ้าของการนำเข้าและลบไฟล์นั้น
• แผนการย้ายข้อมูลลับของ Hermes นำไปใช้และนำเข้าโปรไฟล์คีย์ API โดยตรง สู่ที่จัดเก็บโปรไฟล์การยืนยันตัวตน SQLite ไม่เขียนหรือตรวจสอบ auth-profiles.json เป็นเป้าหมายขั้นกลางอีกต่อไป
• ขณะนี้เอกสารการยืนยันตัวตนสำหรับผู้ใช้อธิบาย state/openclaw.sqlite#table/auth_profile_stores/<agentDir> แทน การบอกให้ผู้ใช้ตรวจสอบหรือคัดลอก auth-profiles.json; ชื่อ JSON ของ OAuth/การยืนยันตัวตน เดิมยังคงมีบันทึกไว้เฉพาะในฐานะอินพุตการนำเข้าของ doctor
• ขณะนี้เซสชัน OAuth ของ MCP ใช้แถว mcp_oauth_stores ที่มีการกำหนดเวอร์ชันใน state/openclaw.sqlite แบบใช้ร่วมกัน ออบเจ็กต์โทเค็น การลงทะเบียนไคลเอ็นต์ และการค้นหา ที่ SDK เป็นเจ้าของยังคงเป็นเพย์โหลด JSON ที่ผ่านการตรวจสอบหนึ่งรายการ เพื่อให้ฟิลด์ส่วนขยายของการพึ่งพา ยังคงอยู่ ขณะที่การอ่าน/แก้ไข/เขียนทุกครั้งคอมมิตในธุรกรรม Kysely ระยะสั้นหนึ่งรายการ lease SQLite แบบใช้ร่วมกันหนึ่งรายการทำให้การรีเฟรช ล็อกอิน และล็อกเอาต์ทำงานตามลำดับ; ทรานสปอร์ต MCP แบบฝังไม่อนุญาตให้ MCP SDK รีเฟรชนอก lease นั้นอีกต่อไป Doctor เป็นผู้นำเข้าและลบที่จัดเก็บ mcp-oauth/*.json ที่เลิกใช้แล้วแต่เพียงผู้เดียวพร้อมใบรับต้นทาง และรันไทม์ไม่มีทางเลือกสำรองแบบไฟล์
• ตัวช่วยพาธสถานะของคอร์ไม่เปิดเผยไฟล์ credentials/oauth.json ที่เลิกใช้แล้วอีกต่อไป ชื่อไฟล์เดิมอยู่เฉพาะในพาธนำเข้าการยืนยันตัวตนของ doctor
• ขณะนี้เอกสารการติดตั้ง ความปลอดภัย การเริ่มต้นใช้งาน การยืนยันตัวตนโมเดล และ SecretRef อธิบาย แถวโปรไฟล์การยืนยันตัวตน SQLite และการสำรองข้อมูล/ย้ายข้อมูลทั้งสถานะ แทน ไฟล์ JSON โปรไฟล์การยืนยันตัวตนต่อเอเจนต์
• ขณะนี้การค้นหาโมเดล PI ส่งข้อมูลประจำตัวหลักไปยังที่จัดเก็บการยืนยันตัวตน pi-coding-agent ในหน่วยความจำ ไม่สร้าง ล้าง หรือเขียน auth.json ต่อเอเจนต์ระหว่างการค้นหาอีกต่อไป
• ขณะนี้การตั้งค่าทริกเกอร์และการกำหนดเส้นทาง Voice Wake ใช้ตาราง SQLite แบบใช้ร่วมกันที่มีชนิดข้อมูล แทน settings/voicewake.json, settings/voicewake-routing.json หรือ แถวทั่วไปแบบทึบ; doctor นำเข้าไฟล์ JSON เดิมและลบไฟล์เหล่านั้นหลัง การย้ายข้อมูลสำเร็จ
• ขณะนี้สถานะการตรวจสอบการอัปเดตใช้แถว update_check_state แบบใช้ร่วมกันที่มีชนิดข้อมูลแทน update-check.json หรือบล็อบทั่วไปแบบทึบ; doctor นำเข้า ไฟล์ JSON เดิมและลบไฟล์หลังการย้ายข้อมูลสำเร็จ
• ขณะนี้สถานะความสมบูรณ์ของการกำหนดค่าใช้แถว config_health_entries แบบใช้ร่วมกันที่มีชนิดข้อมูลแทน logs/config-health.json หรือบล็อบทั่วไปแบบทึบ; doctor นำเข้าไฟล์ JSON เดิมและลบไฟล์หลังการย้ายข้อมูลสำเร็จ
• ขณะนี้การอนุมัติการผูกการสนทนาของ Plugin ใช้แถว plugin_binding_approvals ที่มีชนิดข้อมูลแทนสถานะ SQLite แบบใช้ร่วมกันที่ทึบหรือ plugin-binding-approvals.json; ไฟล์เดิมเป็นอินพุตการย้ายข้อมูลของ doctor
• ขณะนี้การผูกการสนทนาปัจจุบันแบบทั่วไปจัดเก็บแถว current_conversation_bindings ที่มีชนิดข้อมูลแทนการเขียน bindings/current-conversations.json ใหม่; doctor นำเข้าไฟล์ JSON เดิมและ ลบไฟล์หลังการย้ายข้อมูลสำเร็จ
• ขณะนี้บัญชีแยกประเภทการซิงค์แหล่งข้อมูลที่นำเข้าของ Memory Wiki จัดเก็บแถวสถานะ Plugin ใน SQLite หนึ่งแถว ต่อคีย์ vault/แหล่งข้อมูล แทนการเขียน .openclaw-wiki/source-sync.json ใหม่; ผู้ให้บริการการย้ายข้อมูลนำเข้าและลบบัญชีแยกประเภท JSON เดิม
• ขณะนี้ระเบียนการทำงานนำเข้า ChatGPT ของ Memory Wiki จัดเก็บแถวสถานะ Plugin ใน SQLite หนึ่งแถว ต่อ id ของ vault/การทำงาน แทนการเขียน .openclaw-wiki/import-runs/*.json สแนปช็อตสำหรับย้อนกลับยังคงเป็นไฟล์ vault ที่ระบุชัดเจน จนกว่าการเก็บถาวรสแนปช็อต ของการทำงานนำเข้าจะถูกย้ายไปยังที่จัดเก็บบล็อบ
• ขณะนี้ไดเจสต์ที่คอมไพล์ของ Memory Wiki จัดเก็บแถวบล็อบ Plugin ใน SQLite แบบบีบอัด แทนการเขียน .openclaw-wiki/cache/agent-digest.json และ .openclaw-wiki/cache/claims.jsonl แคชสามารถสร้างใหม่ได้ ดังนั้น doctor จึงลบไฟล์แคชเก่าโดยไม่นำเข้า
• ขณะนี้การติดตามการติดตั้ง Skills ของ ClawHub จัดเก็บแถวสถานะ Plugin ใน SQLite หนึ่งแถวต่อ เวิร์กสเปซ/Skills แทนการเขียนหรืออ่าน sidecar .clawhub/lock.json และ .clawhub/origin.json ขณะรันไทม์ โค้ดรันไทม์ใช้ออบเจ็กต์สถานะการติดตั้งที่ติดตาม แทนนามธรรม lockfile/origin ที่มีรูปแบบเหมือนไฟล์ Doctor นำเข้า sidecar เดิมจากเวิร์กสเปซเอเจนต์ที่กำหนดค่าไว้และลบออก หลังการนำเข้าที่สมบูรณ์
• ขณะนี้ดัชนี Plugin ที่ติดตั้งอ่านและเขียนแถว singleton SQLite แบบใช้ร่วมกันที่มีชนิดข้อมูล installed_plugin_index แทน plugins/installs.json; ไฟล์ JSON เดิมเป็นเพียงอินพุตการย้ายข้อมูลของ doctor และจะถูกลบหลังการนำเข้า
• ขณะนี้ตัวช่วยพาธ plugins/installs.json เดิมอยู่ในโค้ดเดิมของ doctor โมดูลดัชนี Plugin ของรันไทม์เปิดเผยเฉพาะตัวเลือกการคงข้อมูลที่รองรับโดย SQLite ไม่ใช่พาธไฟล์ JSON
• ขณะนี้ sentinel การรีสตาร์ต Gateway เจตนาการรีสตาร์ต และสถานะการส่งมอบให้ supervisor ใช้ แถว SQLite แบบใช้ร่วมกันที่มีชนิดข้อมูล (gateway_restart_sentinel, gateway_restart_intent และ gateway_restart_handoff) แทนบล็อบทั่วไป แบบทึบ โค้ดรีสตาร์ตของรันไทม์ไม่มีสัญญา sentinel/intent/handoff ที่มีรูปแบบเหมือนไฟล์
• ขณะนี้แคชการซิงค์ Matrix เมทาดาทาของที่จัดเก็บ การผูกเธรด เครื่องหมายขจัดข้อมูลซ้ำขาเข้า สถานะช่วงพักหลังการตรวจสอบเมื่อเริ่มต้น สแนปช็อตคริปโต IndexedDB ของ SDK ข้อมูลประจำตัว และคีย์กู้คืน ใช้ตารางสถานะ/บล็อบ Plugin ใน SQLite แบบใช้ร่วมกัน โครงสร้างพาธของรันไทม์ไม่เปิดเผยพาธเมทาดาทา storage-meta.json อีกต่อไป; ชื่อไฟล์นั้นเป็นเพียงอินพุตการย้ายข้อมูลเดิม แผนการนำเข้า JSON เดิม อยู่ในพื้นผิวการย้ายข้อมูลการตั้งค่า/doctor ของ Plugin Matrix เครื่องหมาย ขจัดข้อมูลซ้ำขาเข้าใช้ระบบขจัดข้อมูลซ้ำแบบอ้างสิทธิ์ได้ของคอร์ (เนมสเปซ matrix.inbound-dedupe.* ในฐานข้อมูลสถานะแบบใช้ร่วมกัน); การย้ายสถานะของ doctor สำหรับ Matrix นำเข้า แถว inbound-dedupe ต่อรากที่เลิกใช้แล้วและ inbound-dedupe.json หนึ่งครั้ง จากนั้นรันไทม์จะอ่านเฉพาะที่จัดเก็บการขจัดข้อมูลซ้ำแบบอ้างสิทธิ์ได้
• การเริ่มต้น Matrix ไม่สแกน รายงาน หรือดำเนินการสถานะไฟล์ Matrix เดิมให้เสร็จสิ้น อีกต่อไป การตรวจหาไฟล์ Matrix การสร้างสแนปช็อตคริปโตเดิม สถานะการย้าย การกู้คืนคีย์ห้อง การนำเข้า และการลบต้นทาง ล้วนเป็นของ doctor
• นำ barrel การย้ายข้อมูลรันไทม์ Matrix ออกแล้ว ตัวช่วยตรวจหา และแก้ไขสถานะ/คริปโตเดิมถูกนำเข้าโดย doctor ของ Matrix โดยตรง แทนการเป็น ส่วนหนึ่งของพื้นผิว API ของรันไทม์
• ขณะนี้เครื่องหมายการนำสแนปช็อตการย้ายข้อมูล Matrix กลับมาใช้ใหม่อยู่ในสถานะ Plugin ของ SQLite แทน matrix/migration-snapshot.json; doctor ยังคงนำไฟล์เก็บถาวรก่อนการย้ายข้อมูล ที่ผ่านการตรวจสอบเดียวกันกลับมาใช้ใหม่ได้โดยไม่เขียนไฟล์สถานะ sidecar
• ขณะนี้เคอร์เซอร์บัส Nostr และสถานะการเผยแพร่โปรไฟล์ใช้สถานะ Plugin ใน SQLite แบบใช้ร่วมกัน แผนการนำเข้า JSON เดิมอยู่ในพื้นผิวการย้ายข้อมูล การตั้งค่า/doctor ของ Plugin Nostr
• ขณะนี้สวิตช์เปิด/ปิดเซสชัน Active Memory ใช้สถานะ Plugin ใน SQLite แบบใช้ร่วมกันแทน session-toggles.json; การเปิดหน่วยความจำกลับมาจะลบแถวแทน การเขียนออบเจ็กต์ JSON ใหม่
• ขณะนี้ข้อเสนอและตัวนับการรีวิวของ Skill Workshop ใช้สถานะ Plugin ใน SQLite แบบใช้ร่วมกันแทนที่จัดเก็บ skill-workshop/<workspace>.json ต่อเวิร์กสเปซ ข้อเสนอแต่ละรายการ เป็นแถวแยกภายใต้ skill-workshop/proposals และตัวนับการรีวิว เป็นแถวแยกภายใต้ skill-workshop/reviews
• ขณะนี้การทำงานของเอเจนต์ย่อยผู้รีวิว Skill Workshop ใช้ตัวแก้ไขทรานสคริปต์เซสชัน ของรันไทม์ แทนการสร้างพาธเซสชัน sidecar skill-workshop/<sessionId>.json
• ขณะนี้ lease ของโปรเซส ACPX ใช้สถานะ Plugin ใน SQLite แบบใช้ร่วมกันภายใต้ acpx/process-leases แทนรีจิสทรีทั้งไฟล์ process-leases.json แต่ละ lease ถูกจัดเก็บเป็นแถวของตนเอง โดยยังคงการกำจัดโปรเซสค้าง เมื่อเริ่มต้นโดยไม่มีพาธเขียน JSON ใหม่ของรันไทม์
• สคริปต์ตัวห่อ ACPX และโฮม Codex แบบแยกส่วนถูกสร้างใน รากชั่วคราวของ OpenClaw โดยจะถูกสร้างใหม่ตามต้องการและไม่ใช่อินพุต สำหรับการสำรองข้อมูลหรือการย้ายข้อมูล
• การคงข้อมูลรีจิสทรีการทำงานของเอเจนต์ย่อยใช้แถว subagent_runs แบบใช้ร่วมกันที่มีชนิดข้อมูล ขณะนี้พาธ subagents/runs.json เดิมเป็นเพียงอินพุตการล้างข้อมูลของ Doctor เท่านั้น Doctor อ้างสิทธิ์พาธดังกล่าวภายใต้ล็อกการบำรุงรักษาสถานะ บันทึกการตัดสินใจทิ้งข้อมูลใน SQLite และลบออกโดยไม่นำเข้าสถานะการทำงานชั่วคราว ไม่มีตัวอ่าน ตัวเขียน แคช หรือทางเลือกสำรอง JSON ของรันไทม์เหลืออยู่; ไม่รองรับการกู้คืนข้ามเวอร์ชัน ของการทำงานที่กำลังดำเนินการซึ่งมีเฉพาะในไฟล์โดยเจตนา ณ ขอบเขตการเลิกใช้นี้ การทดสอบรันไทม์ไม่สร้างฟิกซ์เจอร์ runs.json ที่ไม่ถูกต้องหรือว่างเปล่าเพื่อพิสูจน์ พฤติกรรมของรีจิสทรีอีกต่อไป; แต่จะตั้งต้น/อ่านแถว SQLite โดยตรง
• การสำรองข้อมูลจัดเตรียมไดเรกทอรีสถานะก่อนเก็บถาวร คัดลอกไฟล์ที่ไม่ใช่ฐานข้อมูล สร้างสแนปช็อตฐานข้อมูลด้วย VACUUM INTO ไม่รวม sidecar WAL/SHM ที่กำลังใช้งาน บันทึก เมทาดาทาสแนปช็อตในแมนิเฟสต์ของไฟล์เก็บถาวร และบันทึก การทำงานสำรองข้อมูลที่เสร็จสมบูรณ์ใน SQLite พร้อมแมนิเฟสต์ของไฟล์เก็บถาวร openclaw backup create ตรวจสอบไฟล์เก็บถาวรที่เขียนแล้วโดยค่าเริ่มต้น; --no-verify คือ พาธด่วนที่ระบุอย่างชัดเจน
• openclaw backup restore ตรวจสอบไฟล์เก็บถาวรก่อนแตกไฟล์ นำแมนิเฟสต์ที่ปรับให้อยู่ในรูปแบบมาตรฐาน ของตัวตรวจสอบกลับมาใช้ใหม่ และคืนค่าแอสเซ็ตในแมนิเฟสต์ที่ผ่านการตรวจสอบไปยัง พาธต้นทางที่บันทึกไว้ ต้องใช้ --yes สำหรับการเขียนและรองรับ --dry-run สำหรับแผนการคืนค่า
• ลบตัวกรองพาธชั่วคราวของการสำรองข้อมูลรุ่นเก่าแล้ว การสำรองข้อมูลไม่ต้องใช้ รายการข้ามสำหรับ tar แบบสดสำหรับไฟล์ JSON/JSONL ของเซสชันหรือ Cron รุ่นเก่าอีกต่อไป เพราะสแนปช็อต SQLite ถูกจัดเตรียมก่อนสร้างไฟล์เก็บถาวร
• การตั้งค่าแบบปกติและการเตรียมพื้นที่ทำงานสำหรับการเริ่มต้นใช้งานจะไม่สร้างไดเรกทอรี agents/<agentId>/sessions/ อีกต่อไป โดยจะสร้างเฉพาะการกำหนดค่า/พื้นที่ทำงานเท่านั้น แถวเซสชันและแถวบทสนทนาใน SQLite จะถูกสร้างตามความต้องการใน ฐานข้อมูลของแต่ละเอเจนต์
• ขณะนี้การซ่อมแซมสิทธิ์ด้านความปลอดภัยมุ่งเป้าไปที่ฐานข้อมูล SQLite ส่วนกลางและของแต่ละเอเจนต์ รวมถึงไฟล์เสริม WAL/SHM แทน sessions.json และไฟล์บทสนทนา JSONL
• ขณะนี้ชื่อรันไทม์ของรีจิสทรี Sandbox อธิบายชนิดของรีจิสทรี SQLite โดยตรง แทนการใช้คำศัพท์รีจิสทรี JSON แบบเดิมต่อไปในที่เก็บข้อมูลที่ใช้งานอยู่
• openclaw reset --scope config+creds+sessions จะลบฐานข้อมูล openclaw-agent.sqlite ของแต่ละเอเจนต์พร้อมไฟล์เสริม WAL/SHM ไม่ใช่เพียง ไดเรกทอรี sessions/ แบบเดิม
• ขณะนี้ตัวช่วยเซสชันรวมของ Gateway ใช้ชื่อที่เน้นรายการ: loadCombinedSessionEntriesForGateway ส่งคืน { databasePath, entries } ชื่อแบบเก่าที่อ้างถึงที่เก็บข้อมูลแบบรวมถูกนำออกจากผู้เรียกใช้ในรันไทม์แล้ว
• ขณะนี้การเตรียมข้อมูลเริ่มต้นให้ช่องทาง MCP ของ Docker จะเขียนแถวเซสชันหลักและเหตุการณ์บทสนทนา ลงในฐานข้อมูล SQLite ของแต่ละเอเจนต์ แทนการสร้าง sessions.json และบทสนทนา JSONL
• ขณะนี้ฮุกหน่วยความจำเซสชันที่รวมมาให้จะค้นหาบริบทของเซสชันก่อนหน้าจาก SQLite ด้วย {agentId, sessionId} โดยจะไม่สแกน จัดเก็บ หรือสังเคราะห์ พาธบทสนทนาหรือไดเรกทอรี workspace/sessions อีกต่อไป
• ขณะนี้ฮุกบันทึกคำสั่งที่รวมมาให้จะเขียนแถวการตรวจสอบคำสั่งลงในตาราง command_log_entries ของ SQLite ที่ใช้ร่วมกัน แทนการต่อท้าย logs/commands.log
• ขณะนี้รายการอนุญาตสำหรับการจับคู่ช่องทางเปิดเผยเฉพาะตัวช่วยอ่าน/เขียนที่รองรับด้วย SQLite ในรันไทม์ ตัวแก้พาธของ SDK สำหรับ Plugin ที่เลิกใช้แล้วยังคงอยู่เพื่อความเข้ากันได้ ในการย้ายข้อมูล ส่วนตัวอ่านไฟล์จะอยู่เฉพาะในโค้ดย้ายสถานะของ doctor เท่านั้น
• migration_runs บันทึกการดำเนินการย้ายสถานะแบบเดิม พร้อมสถานะ การประทับเวลา และรายงาน JSON
• migration_sources บันทึกแหล่งที่มาของไฟล์แบบเดิมแต่ละไฟล์ที่นำเข้า พร้อมแฮช ขนาด จำนวนระเบียน ตารางเป้าหมาย รหัสการดำเนินการ สถานะ และสถานะการนำแหล่งที่มาออก
• backup_runs บันทึกพาธไฟล์เก็บถาวรสำรอง สถานะ และแมนิเฟสต์ JSON
• สคีมาส่วนกลางจะไม่เก็บตารางรีจิสทรี agents ที่ไม่ได้ใช้ การค้นหา ฐานข้อมูลเอเจนต์คือรีจิสทรี agent_databases มาตรฐาน จนกว่ารันไทม์ จะมีเจ้าของระเบียนเอเจนต์จริง
• การกำหนดค่าแค็ตตาล็อกโมเดลที่สร้างขึ้นจะถูกจัดเก็บในแถว agent_model_catalogs ของ SQLite ส่วนกลางแบบมีชนิด โดยใช้ไดเรกทอรีเอเจนต์เป็นคีย์ ผู้เรียกใช้ในรันไทม์ใช้ ensureOpenClawModelCatalog; ไม่มี API ความเข้ากันได้ models.json ใน โค้ดรันไทม์ การใช้งานจะเขียนลง SQLite และรีจิสทรี PI แบบฝังตัวจะได้รับข้อมูล จากเพย์โหลดที่จัดเก็บไว้โดยไม่สร้างไฟล์ models.json
• การส่งออก memory.qmd.sessions ซึ่งเป็นทางเลือก จะอ่านแถวบทสนทนามาตรฐานจาก ฐานข้อมูลของแต่ละเอเจนต์ และสร้าง Markdown ที่ผ่านการทำให้ปลอดภัยภายใต้โฮมของ QMD เพื่อเป็นอาร์ติแฟกต์อินพุต QMD อย่างชัดเจน ดังนั้นคอลเลกชันเซสชัน QMD และการแมป ข้อมูลประจำตัวของอาร์ติแฟกต์จึงยังคงเป็นส่วนหนึ่งของบริดจ์เครื่องมือภายนอกที่กำหนดค่าไว้ ไม่ใช่ที่เก็บบทสนทนามาตรฐานชุดที่สอง
• index.sqlite ของ QMD เอง การกำหนดค่าคอลเลกชัน YAML และการดาวน์โหลดโมเดลยังคงเป็น อาร์ติแฟกต์ของเครื่องมือภายนอกภายใต้ ~/.openclaw/agents/<agentId>/qmd; โดยจะไม่ถูก ทำสำเนาลงใน plugin_blob_entries การประสานงาน QMD ที่ OpenClaw เป็นเจ้าของ ใช้ฐานข้อมูลเป็นหลัก: state_leases ที่ใช้ร่วมกันจะจัดลำดับการฝังข้อมูลส่วนกลาง และ state_leases ของแต่ละเอเจนต์จะจัดลำดับตัวเขียนคอลเลกชัน/การอัปเดต/การฝังข้อมูล รันไทม์จะไม่สร้าง ไฟล์เสริมล็อก QMD
• Plugin memory-lancedb ซึ่งเป็นทางเลือกจะไม่สร้าง ~/.openclaw/memory/lancedb เป็นที่เก็บข้อมูลโดยนัยที่ OpenClaw จัดการอีกต่อไป โดยเป็น แบ็กเอนด์ LanceDB ภายนอกและจะยังคงปิดใช้งานจนกว่าผู้ดำเนินการจะกำหนดค่า dbPath อย่างชัดเจน
• check:database-first-legacy-stores จะทำให้ซอร์สรันไทม์ใหม่ที่จับคู่ ชื่อที่เก็บข้อมูลแบบเดิมกับ API ระบบไฟล์แบบเขียนล้มเหลว และยังทำให้ซอร์สรันไทม์ ที่นำเครื่องหมายบริดจ์บทสนทนาที่เลิกใช้แล้วกลับมา ได้แก่ transcriptLocator หรือ sqlite-transcript://... ล้มเหลวด้วย โค้ดสำหรับการย้ายข้อมูล doctor การนำเข้า และการส่งออกที่ไม่ใช่เซสชันอย่างชัดเจนยังคงได้รับอนุญาต ชื่อสัญญาแบบเดิมที่กว้างกว่า เช่น sessionFile, storePath และฟาซาดจากยุคไฟล์ SessionManager แบบเก่า ยังคงมีเจ้าของปัจจุบันและต้องมีงานตัวป้องกันการย้ายข้อมูลแยกต่างหาก ก่อนจะกลายเป็นการตรวจสอบล่วงหน้าที่จำเป็น ขณะนี้ตัวป้องกันยังครอบคลุม ที่เก็บ cache/*.json ในรันไทม์ ไฟล์เสริม thread-bindings.json ทั่วไป สถานะ Cron/JSON บันทึกการทำงาน JSON สถานะการกำหนดค่า ไฟล์เสริมการรีสตาร์ตและล็อก การตั้งค่า Voice Wake การอนุมัติการผูก Plugin JSON ดัชนี Plugin ที่ติดตั้ง JSONL การตรวจสอบ File Transfer บันทึกกิจกรรม Memory Wiki บันทึกข้อความ command-logger แบบเก่าที่รวมมาให้ และตัวเลือกการวินิจฉัย JSONL สตรีมดิบของ pi-mono นอกจากนี้ยังห้ามชื่อโมดูล doctor แบบเดิมที่ระดับราก เพื่อให้โค้ดความเข้ากันได้คงอยู่ภายใต้ src/commands/doctor/ ตัวจัดการดีบักของ Android ยังใช้ logcat/เอาต์พุตในหน่วยความจำแทนการพักไฟล์แคช camera_debug.log หรือ debug_logs.txt ด้วย

รูปแบบสคีมาเป้าหมาย

กำหนดสคีมาไว้อย่างชัดเจน สถานะรันไทม์ที่โฮสต์เป็นเจ้าของใช้ตารางที่มีชนิดข้อมูล สถานะทึบแสงที่ Plugin เป็นเจ้าของ ใช้ plugin_state_entries / plugin_blob_entries; ไม่มีตาราง kv แบบทั่วไปของโฮสต์

ฐานข้อมูลส่วนกลาง:

state_leases(scope, lease_key, owner, expires_at, heartbeat_at, payload_json, created_at, updated_at)exec_approvals_config(config_key, raw_json, socket_path, has_socket_token, default_security, default_ask, default_ask_fallback, auto_allow_skills, agent_count, allowlist_count, updated_at_ms)schema_meta(meta_key, role, schema_version, agent_id, app_version, created_at, updated_at)agent_databases(agent_id, path, schema_version, last_seen_at, size_bytes)task_runs(...)task_delivery_state(...)flow_runs(...)subagent_runs(run_id, child_session_key, requester_session_key, controller_session_key, created_at, ended_at, cleanup_handled, payload_json)current_conversation_bindings(binding_key, binding_id, target_agent_id, target_session_id, target_session_key, channel, account_id, conversation_kind, parent_conversation_id, conversation_id, target_kind, status, bound_at, expires_at, metadata_json, updated_at)plugin_binding_approvals(plugin_root, channel, account_id, plugin_id, plugin_name, approved_at)tui_last_sessions(scope_key, session_key, updated_at)plugin_state_entries(plugin_id, namespace, entry_key, value_json, created_at, expires_at)plugin_blob_entries(plugin_id, namespace, entry_key, metadata_json, blob, created_at, expires_at)media_blobs(subdir, id, content_type, size_bytes, blob, created_at, updated_at)skill_uploads(upload_id, kind, slug, force, size_bytes, sha256, actual_sha256, received_bytes, archive_blob, created_at, expires_at, committed, committed_at, idempotency_key_hash)skill_upload_chunks(upload_id, byte_offset, size_bytes, chunk_blob)web_push_subscriptions(endpoint_hash, subscription_id, endpoint, p256dh, auth, created_at_ms, updated_at_ms)web_push_vapid_keys(key_id, public_key, private_key, subject, updated_at_ms)apns_registrations(node_id, transport, token, relay_handle, send_grant, installation_id, relay_origin, topic, environment, distribution, token_debug_suffix, updated_at_ms)apns_registration_tombstones(node_id, deleted_at_ms)node_host_config(config_key, version, node_id, token, display_name, gateway_host, gateway_port, gateway_tls, gateway_tls_fingerprint, gateway_context_path, updated_at_ms)device_identities(identity_key, device_id, public_key_pem, private_key_pem, created_at_ms, updated_at_ms)device_auth_tokens(device_id, role, token, scopes_json, updated_at_ms)macos_port_guardian_records(pid, port, command, mode, timestamp)workspace_setup_state(workspace_key, workspace_path, version, bootstrap_seeded_at, setup_completed_at, updated_at)workspace_path_aliases(alias_key, alias_path, workspace_key, workspace_path, updated_at_ms)workspace_attestations(workspace_key, attested_at_ms, updated_at_ms)workspace_generated_bootstrap_hashes(workspace_key, filename, sha256)native_hook_relay_bridges(relay_id, pid, hostname, port, token, expires_at_ms, updated_at_ms)model_capability_cache(provider_id, model_id, name, input_text, input_image, reasoning, supports_tools, context_window, max_tokens, cost_input, cost_output, cost_cache_read, cost_cache_write, updated_at_ms)agent_model_catalogs(catalog_key, agent_dir, raw_json, updated_at)managed_outgoing_image_records(attachment_id, session_key, agent_id, message_id, created_at, updated_at, retention_class, alt, original_media_id, original_media_subdir, original_content_type, original_width, original_height, original_size_bytes, original_filename, record_json, cleanup_pending)gateway_restart_sentinel(sentinel_key, version, kind, status, ts, session_key, thread_id, delivery_channel, delivery_to, delivery_account_id, message, continuation_json, doctor_hint, stats_json, payload_json, updated_at_ms)channel_pairing_requests(channel_key, account_id, request_id, code, created_at, last_seen_at, meta_json)channel_pairing_allow_entries(channel_key, account_id, entry, sort_order, updated_at)voicewake_triggers(config_key, position, trigger, updated_at_ms)voicewake_routing_config(config_key, version, default_target_mode, default_target_agent_id, default_target_session_key, updated_at_ms)voicewake_routing_routes(config_key, position, trigger, target_mode, target_agent_id, target_session_key, updated_at_ms)update_check_state(state_key, last_checked_at, last_notified_version, last_notified_tag, last_available_version, last_available_tag, auto_install_id, auto_first_seen_version, auto_first_seen_tag, auto_first_seen_at, auto_last_attempt_version, auto_last_attempt_at, auto_last_success_version, auto_last_success_at, updated_at_ms)config_health_entries(config_path, last_known_good_json, last_promoted_good_json, last_observed_suspicious_signature, updated_at_ms)sandbox_registry_entries(registry_kind, container_name, session_key, backend_id, runtime_label, image, created_at_ms, last_used_at_ms, config_label_kind, config_hash, cdp_port, no_vnc_port, entry_json, updated_at)cron_jobs(store_key, job_id, name, description, enabled, delete_after_run, created_at_ms, agent_id, session_key, schedule_kind, schedule_expr, schedule_tz, every_ms, anchor_ms, at, stagger_ms, session_target, wake_mode, payload_kind, payload_message, payload_model, payload_fallbacks_json, payload_thinking, payload_timeout_seconds, payload_allow_unsafe_external_content, payload_external_content_source_json, payload_light_context, payload_tools_allow_json, delivery_mode, delivery_channel, delivery_to, delivery_thread_id, delivery_account_id, delivery_best_effort, failure_delivery_mode, failure_delivery_channel, failure_delivery_to, failure_delivery_account_id, failure_alert_disabled, failure_alert_after, failure_alert_channel, failure_alert_to, failure_alert_cooldown_ms, failure_alert_include_skipped, failure_alert_mode, failure_alert_account_id, next_run_at_ms, running_at_ms, last_run_at_ms, last_run_status, last_error, last_duration_ms, consecutive_errors, consecutive_skipped, schedule_error_count, last_delivery_status, last_delivery_error, last_delivered, last_failure_alert_at_ms, job_json, state_json, runtime_updated_at_ms, schedule_identity, sort_order, updated_at)delivery_queue_entries(queue_name, id, status, entry_kind, session_key, channel, target, account_id, retry_count, last_attempt_at, last_error, recovery_state, platform_send_started_at, entry_json, enqueued_at, updated_at, failed_at)commitments(id, agent_id, session_key, channel, account_id, recipient_id, thread_id, sender_id, kind, sensitivity, source, status, reason, suggested_text, dedupe_key, confidence, due_earliest_ms, due_latest_ms, due_timezone, source_message_id, source_run_id, created_at_ms, updated_at_ms, attempts, last_attempt_at_ms, sent_at_ms, dismissed_at_ms, snoozed_until_ms, expired_at_ms, record_json)migration_runs(id, started_at, finished_at, status, report_json)migration_sources(source_key, migration_kind, source_path, target_table, source_sha256, source_size_bytes, source_record_count, last_run_id, status, imported_at, removed_source, report_json)backup_runs(id, created_at, archive_path, status, manifest_json)

ฐานข้อมูลเอเจนต์:

schema_meta(meta_key, role, schema_version, agent_id, app_version, created_at, updated_at)sessions(session_id, session_key, session_scope, created_at, updated_at, started_at, ended_at, status, chat_type, channel, account_id, primary_conversation_id, model_provider, model, agent_harness_id, parent_session_key, spawned_by, display_name)conversations(conversation_id, channel, account_id, kind, peer_id, parent_conversation_id, thread_id, native_channel_id, native_direct_user_id, label, metadata_json, created_at, updated_at)session_conversations(session_id, conversation_id, role, first_seen_at, last_seen_at)session_routes(session_key, session_id, updated_at)session_entries(session_id, session_key, entry_json, updated_at)transcript_events(session_id, seq, event_json, created_at)transcript_event_identities(session_id, event_id, seq, event_type, has_parent, parent_id, message_idempotency_key, created_at)transcript_snapshots(session_id, snapshot_id, reason, event_count, created_at, metadata_json)vfs_entries(namespace, path, kind, content_blob, metadata_json, updated_at)tool_artifacts(run_id, artifact_id, kind, metadata_json, blob, created_at)run_artifacts(run_id, path, kind, metadata_json, blob, created_at)trajectory_runtime_events(session_id, run_id, seq, event_json, created_at)memory_index_meta(key, value)memory_index_sources(id, path, source, hash, mtime, size)memory_index_chunks(id, path, source, start_line, end_line, hash, model, text, embedding, updated_at)memory_embedding_cache(provider, model, provider_key, hash, embedding, dims, updated_at)memory_index_state(id, revision)cache_entries(scope, key, value_json, blob, expires_at, updated_at)

memory_index_sources.id คือคีย์หลักจำนวนเต็มที่มีความเสถียร; (path, source) ยังคงไม่ซ้ำกัน

การค้นหาในอนาคตสามารถเพิ่มตาราง FTS ได้โดยไม่ต้องเปลี่ยนตารางเหตุการณ์หลัก:

transcript_events_fts(session_id, seq, text)vfs_entries_fts(namespace, path, text)

ค่าขนาดใหญ่ควรใช้คอลัมน์ blob ไม่ใช่การเข้ารหัสเป็นสตริง JSON ให้คง value_json ไว้สำหรับข้อมูลแบบมีโครงสร้างขนาดเล็กที่ต้องยังตรวจสอบได้ด้วยเครื่องมือ SQLite ทั่วไป

agent_databases คือรีจิสทรีหลักสำหรับสาขานี้ อย่าเพิ่มตาราง agents จนกว่าจะมีเจ้าของระเบียนเอเจนต์จริง; การกำหนดค่าเอเจนต์ยังคงอยู่ใน openclaw.json

รูปแบบการย้ายข้อมูลของ Doctor

Doctor ควรเรียกขั้นตอนการย้ายข้อมูลที่ชัดเจนเพียงขั้นตอนเดียว ซึ่งรายงานผลได้และ เรียกซ้ำได้อย่างปลอดภัย:

openclaw doctor --fix

openclaw doctor --fix เรียกใช้การนำการย้ายสถานะไปใช้หลังจาก การตรวจสอบเบื้องต้นของการกำหนดค่าตามปกติ และสร้างข้อมูลสำรองที่ผ่านการตรวจสอบก่อนนำเข้า การเริ่มต้น รันไทม์และ openclaw migrate ต้องไม่นำเข้าไฟล์สถานะ OpenClaw แบบเดิม

คุณสมบัติของการย้ายข้อมูล:

• การย้ายข้อมูลหนึ่งรอบค้นหาแหล่งไฟล์แบบเดิมทั้งหมดและสร้างแผน ก่อนเปลี่ยนแปลงสิ่งใด
• Doctor สร้างไฟล์เก็บถาวรสำรองก่อนการย้ายข้อมูลที่ผ่านการตรวจสอบแล้วก่อนนำเข้า ไฟล์แบบเดิม
• การนำเข้าสามารถทำซ้ำได้โดยให้ผลเดิม และกำหนดคีย์ด้วยพาธต้นทาง, mtime, ขนาด, แฮช และตาราง เป้าหมาย
• ไฟล์ต้นทางที่ดำเนินการสำเร็จจะถูกลบหรือเก็บถาวรหลังจากฐานข้อมูลเป้าหมาย คอมมิตแล้ว
• การนำเข้าที่ล้มเหลวจะไม่เปลี่ยนแปลงต้นทาง และบันทึกคำเตือนไว้ใน migration_runs
• โค้ดรันไทม์อ่านจาก SQLite เท่านั้นหลังจากมีการย้ายข้อมูลแล้ว
• ไม่จำเป็นต้องมีพาธสำหรับดาวน์เกรดหรือส่งออกกลับไปเป็นไฟล์รันไทม์

รายการสิ่งที่ต้องย้ายข้อมูล

ย้ายรายการเหล่านี้ไปยังฐานข้อมูลส่วนกลาง:

• ขณะนี้การเขียนข้อมูลขณะรันไทม์ของรีจิสทรีงานใช้ฐานข้อมูลที่ใช้ร่วมกันแล้ว และได้ลบตัวนำเข้า sidecar tasks/runs.sqlite ที่ยังไม่เคยเผยแพร่แล้ว การบันทึกสแนปช็อตจะ upsert ตาม id งาน และลบเฉพาะแถวงาน/การส่งมอบที่หายไป
• ขณะนี้การเขียนข้อมูลขณะรันไทม์ของ Task Flow ใช้ฐานข้อมูลที่ใช้ร่วมกันแล้ว และได้ลบตัวนำเข้า sidecar tasks/flows/registry.sqlite ที่ยังไม่เคยเผยแพร่แล้ว การบันทึกสแนปช็อต จะ upsert ตาม id โฟลว์ และลบเฉพาะแถวโฟลว์ที่หายไป
• ขณะนี้การเขียนข้อมูลขณะรันไทม์ของสถานะ Plugin ใช้ฐานข้อมูลที่ใช้ร่วมกันแล้ว และได้ลบตัวนำเข้า sidecar plugin-state/state.sqlite ที่ยังไม่เคยเผยแพร่แล้ว
• การค้นหาหน่วยความจำในตัวจะไม่ใช้ memory/<agentId>.sqlite เป็นค่าเริ่มต้นอีกต่อไป โดยตารางดัชนี อยู่ในฐานข้อมูลของเอเจนต์เจ้าของ และได้เลิกใช้การเลือกใช้ sidecar memorySearch.store.path แบบชัดแจ้งแล้ว โดยย้ายไปยังการย้ายข้อมูลการกำหนดค่าของ doctor
• การสร้างดัชนีหน่วยความจำในตัวใหม่จะรีเซ็ตเฉพาะตารางที่หน่วยความจำเป็นเจ้าของในฐานข้อมูลเอเจนต์ ห้ามแทนที่ไฟล์ SQLite ทั้งไฟล์ เนื่องจากฐานข้อมูลเดียวกันนี้เป็นเจ้าของ เซสชัน ทรานสคริปต์ แถว VFS อาร์ติแฟกต์ และแคชขณะรันไทม์
• รีจิสทรีคอนเทนเนอร์/เบราว์เซอร์ของแซนด์บ็อกซ์จาก JSON แบบรวมศูนย์และแบบแบ่งส่วน ขณะนี้ การเขียนข้อมูลขณะรันไทม์ใช้ฐานข้อมูลที่ใช้ร่วมกันแล้ว และยังคงรองรับการนำเข้า JSON เดิม
• ขณะนี้คำจำกัดความงาน Cron สถานะกำหนดเวลา และประวัติการรันใช้ SQLite ที่ใช้ร่วมกัน โดย doctor จะนำเข้า/ลบไฟล์ jobs.json, jobs-state.json และ cron/runs/*.jsonl เดิม
• ข้อมูลประจำตัว/การยืนยันตัวตนของอุปกรณ์ การพุช การตรวจสอบการอัปเดต ข้อผูกมัด แคชโมเดล OpenRouter ดัชนี Plugin ที่ติดตั้ง และการผูกเซิร์ฟเวอร์แอป
• ขณะนี้ระเบียนการจับคู่อุปกรณ์/โหนดและการบูตสแตรปใช้ตาราง SQLite แบบมีชนิด
• ขณะนี้สมาชิกที่รับการแจ้งเตือนการจับคู่อุปกรณ์และตัวทำเครื่องหมายคำขอที่ส่งแล้วใช้ตารางสถานะ Plugin SQLite ที่ใช้ร่วมกันแทน device-pair-notify.json
• ขณะนี้ระเบียนการโทรแบบเสียงใช้ตารางสถานะ Plugin SQLite ที่ใช้ร่วมกันภายใต้เนมสเปซ voice-call / calls แทน calls.jsonl โดย CLI ของ Plugin จะติดตามและสรุปประวัติการโทรที่รองรับด้วย SQLite
• ขณะนี้เซสชัน Gateway ของ QQBot ระเบียนผู้ใช้ที่รู้จัก และแคชคำพูดอ้างอิงของดัชนีการอ้างอิงใช้ สถานะ Plugin SQLite ภายใต้เนมสเปซ qqbot (gateway-sessions, known-users, ref-index) แทน session-*.json, known-users.json และ ref-index.jsonl ไฟล์เดิมเหล่านั้นเป็นแคชและจะไม่ถูกย้ายข้อมูล
• ขณะนี้การกำหนดค่าตัวเลือกโมเดลของ Discord แฮชการปรับใช้คำสั่ง และการผูกเธรด ใช้สถานะ Plugin SQLite ภายใต้เนมสเปซ discord (model-picker-preferences, command-deploy-hashes, thread-bindings) แทน model-picker-preferences.json, command-deploy-cache.json และ thread-bindings.json โดยการย้ายข้อมูล doctor/การตั้งค่าของ Discord จะนำเข้าและ ลบไฟล์เดิม
• ขณะนี้เคอร์เซอร์การตามข้อมูลย้อนหลังและตัวทำเครื่องหมายการขจัดข้อมูลซ้ำขาเข้าของ BlueBubbles ใช้สถานะ Plugin SQLite ภายใต้เนมสเปซ bluebubbles (catchup-cursors, inbound-dedupe) แทน bluebubbles/catchup/*.json และ bluebubbles/inbound-dedupe/*.json โดยการย้ายข้อมูล doctor/การตั้งค่าของ BlueBubbles จะนำเข้าและลบไฟล์เดิม
• ขณะนี้ออฟเซ็ตการอัปเดต รายการแคชสติกเกอร์ รายการแคชข้อความในสายการตอบกลับ รายการแคชข้อความที่ส่ง รายการแคชชื่อหัวข้อ และการผูกเธรดของ Telegram ใช้สถานะ Plugin SQLite ภายใต้เนมสเปซ telegram (update-offsets, sticker-cache, message-cache, sent-messages, topic-names, thread-bindings) แทน update-offset-*.json, sticker-cache.json, *.telegram-messages.json, *.telegram-sent-messages.json, *.telegram-topic-names.json และ thread-bindings-*.json โดยการย้ายข้อมูล doctor/การตั้งค่าของ Telegram จะนำเข้าและ ลบไฟล์เดิม
• ขณะนี้เคอร์เซอร์การตามข้อมูลย้อนหลัง การแมป short-id ของการตอบกลับ และแถวขจัดเสียงสะท้อนของข้อความที่ส่งซ้ำ ของ iMessage ใช้สถานะ Plugin SQLite ภายใต้เนมสเปซ imessage (catchup-cursors, reply-cache, sent-echoes) แทน imessage/catchup/*.json, imessage/reply-cache.jsonl และ imessage/sent-echoes.jsonl โดยการย้ายข้อมูล doctor/การตั้งค่าของ iMessage จะนำเข้าและลบไฟล์เดิม
• ขณะนี้การสนทนา โพล โทเค็น SSO และข้อมูลการเรียนรู้จากข้อเสนอแนะของ Microsoft Teams ใช้เนมสเปซสถานะ Plugin SQLite (conversations, polls, sso-tokens, feedback-learnings) แทน msteams-conversations.json, msteams-polls.json, msteams-sso-tokens.json และ *.learnings.json โดยการย้ายข้อมูล doctor/การตั้งค่าของ Microsoft Teams จะนำเข้าและเก็บไฟล์เดิมเข้าคลัง การอัปโหลดที่รอดำเนินการเป็นแคช SQLite อายุสั้น และไฟล์แคช JSON เก่า จะไม่ถูกย้ายข้อมูล
• ขณะนี้แคชการซิงค์ เมทาดาทาพื้นที่จัดเก็บ การผูกเธรด ตัวทำเครื่องหมายการขจัดข้อมูลซ้ำขาเข้า สถานะช่วงพักการตรวจสอบเมื่อเริ่มต้น ข้อมูลรับรอง คีย์การกู้คืน และสแนปช็อตการเข้ารหัส IndexedDB ของ SDK สำหรับ Matrix ใช้เนมสเปซสถานะ/บล็อบของ Plugin SQLite ภายใต้ matrix (sync-store, storage-meta, thread-bindings, matrix.inbound-dedupe.* ผ่านการขจัดข้อมูลซ้ำแบบอ้างสิทธิ์ได้ของคอร์ startup-verification, credentials, recovery-key, idb-snapshots) แทน bot-storage.json, storage-meta.json, thread-bindings.json, inbound-dedupe.json, startup-verification.json, credentials.json, recovery-key.json และ crypto-idb-snapshot.json โดยการย้ายข้อมูล doctor/การตั้งค่า ของ Matrix จะนำเข้าและลบไฟล์เดิมเหล่านั้น (รวมถึงแถว SQLite inbound-dedupe แบบต่อรากที่เลิกใช้แล้ว) จากรากพื้นที่จัดเก็บ Matrix ที่กำหนดขอบเขตตามบัญชี
• ขณะนี้เคอร์เซอร์บัสและสถานะการเผยแพร่โปรไฟล์ของ Nostr ใช้สถานะ Plugin SQLite ภายใต้ เนมสเปซ nostr (bus-state, profile-state) แทน bus-state-*.json และ profile-state-*.json โดยการย้ายข้อมูล doctor/การตั้งค่า ของ Nostr จะนำเข้าและลบไฟล์เดิม
• ขณะนี้ตัวสลับเซสชัน Active Memory ใช้สถานะ Plugin SQLite ภายใต้ active-memory/session-toggles แทน session-toggles.json
• ขณะนี้คิวข้อเสนอและตัวนับการรีวิวของ Skill Workshop ใช้สถานะ Plugin SQLite ภายใต้ skill-workshop/proposals และ skill-workshop/reviews แทน ไฟล์ skill-workshop/<workspace>.json แบบต่อเวิร์กสเปซ
• ขณะนี้คิวการส่งมอบขาออกและการส่งมอบเซสชันใช้ตาราง SQLite ส่วนกลาง delivery_queue_entries ร่วมกันภายใต้ชื่อคิวที่แยกกัน (outbound-delivery, session-delivery) แทนไฟล์ถาวร delivery-queue/*.json, delivery-queue/failed/*.json และ session-delivery-queue/*.json ขั้นตอนสถานะเดิมของ doctor จะนำเข้า แถวที่รอดำเนินการและล้มเหลว ลบตัวทำเครื่องหมายการส่งแล้วที่ล้าสมัย และลบไฟล์ JSON เก่าหลังการนำเข้า ฟิลด์การกำหนดเส้นทางแบบทันทีและการลองใหม่เป็นคอลัมน์แบบมีชนิด ส่วนเพย์โหลด JSON จะเก็บไว้เฉพาะสำหรับการเล่นซ้ำ/ดีบัก
• ขณะนี้ลีสกระบวนการ ACPX ใช้สถานะ Plugin SQLite ภายใต้ acpx/process-leases แทน process-leases.json
• เมทาดาทาการรันการสำรองข้อมูลและการย้ายข้อมูล

ย้ายรายการต่อไปนี้ไปยังฐานข้อมูลเอเจนต์:

• รากเซสชันของเอเจนต์และเพย์โหลดรายการเซสชันที่มีรูปแบบเพื่อความเข้ากันได้ ดำเนินการแล้วสำหรับ การเขียนข้อมูลขณะรันไทม์: สามารถสืบค้นเมทาดาทาเซสชันที่ใช้งานบ่อยได้ใน sessions ขณะที่ เพย์โหลด SessionEntry แบบเต็มที่มีรูปแบบเดิมยังคงอยู่ใน session_entries
• เหตุการณ์ทรานสคริปต์ของเอเจนต์ ดำเนินการแล้วสำหรับการเขียนข้อมูลขณะรันไทม์
• เช็กพอยต์ Compaction และสแนปช็อตทรานสคริปต์ ดำเนินการแล้วสำหรับการเขียนข้อมูลขณะรันไทม์: สำเนาทรานสคริปต์ของเช็กพอยต์เป็นแถวทรานสคริปต์ SQLite และเมทาดาทาเช็กพอยต์ ถูกบันทึกใน transcript_snapshots ขณะนี้ตัวช่วยเช็กพอยต์ของ Gateway เรียกค่าเหล่านี้ว่าสแนปช็อตทรานสคริปต์แทนไฟล์ต้นทาง
• เนมสเปซพื้นที่ชั่วคราว/เวิร์กสเปซ VFS ของเอเจนต์ ดำเนินการแล้วสำหรับการเขียน VFS ขณะรันไทม์
• เพย์โหลดไฟล์แนบของเอเจนต์ย่อย ดำเนินการแล้วสำหรับการเขียนข้อมูลขณะรันไทม์: รายการเหล่านี้เป็นรายการตั้งต้น VFS ของ SQLite และไม่เป็นไฟล์เวิร์กสเปซถาวร
• อาร์ติแฟกต์ของเครื่องมือ ดำเนินการแล้วสำหรับการเขียนข้อมูลขณะรันไทม์
• อาร์ติแฟกต์การรัน ดำเนินการแล้วสำหรับการเขียนข้อมูลขณะรันไทม์ของเวิร์กเกอร์ผ่านตาราง run_artifacts แบบต่อเอเจนต์
• แคชขณะรันไทม์ภายในเอเจนต์ ดำเนินการแล้วสำหรับการเขียนแคชที่กำหนดขอบเขตขณะรันไทม์ของเวิร์กเกอร์ผ่าน ตาราง cache_entries แบบต่อเอเจนต์ แคชโมเดลทั่วทั้ง Gateway ยังคงอยู่ใน ฐานข้อมูลส่วนกลาง เว้นแต่จะกลายเป็นข้อมูลเฉพาะเอเจนต์
• บันทึกสตรีมหลักของ ACP ดำเนินการแล้วสำหรับการเขียนข้อมูลขณะรันไทม์
• เซสชันบัญชีแยกประเภทการเล่นซ้ำของ ACP ดำเนินการแล้วสำหรับการเขียนข้อมูลขณะรันไทม์ผ่าน acp_replay_sessions และ acp_replay_events ส่วน acp/event-ledger.json เดิม ยังคงใช้เป็นข้อมูลนำเข้าของ doctor เท่านั้น
• เมทาดาทาเซสชัน ACP ดำเนินการแล้วสำหรับการเขียนข้อมูลขณะรันไทม์ผ่าน acp_sessions ส่วนบล็อก entry.acp เดิมใน sessions.json เป็นเพียงข้อมูลนำเข้าสำหรับการย้ายข้อมูลของ doctor
• sidecar ของวิถีการทำงานเมื่อไม่ใช่ไฟล์ส่งออกโดยชัดแจ้ง ดำเนินการแล้วสำหรับการเขียนข้อมูล ขณะรันไทม์: การบันทึกวิถีการทำงานเขียนแถว trajectory_runtime_events ในฐานข้อมูลเอเจนต์ และทำมิเรอร์อาร์ติแฟกต์ที่กำหนดขอบเขตตามการรันไปยัง SQLite sidecar เดิมเป็นเพียง ข้อมูลนำเข้าสำหรับ doctor ส่วนการส่งออกสามารถสร้างเอาต์พุตชุดข้อมูลสนับสนุน JSONL ใหม่ แต่จะไม่อ่านหรือย้ายข้อมูล sidecar ของวิถีการทำงาน/ทรานสคริปต์เก่าขณะรันไทม์ การบันทึกวิถีการทำงานขณะรันไทม์เปิดเผยขอบเขต SQLite ส่วนตัวช่วยพาธ JSONL แยกไว้สำหรับการรองรับการส่งออก/ดีบัก และไม่ได้ส่งออกซ้ำจากโมดูลขณะรันไทม์ เมทาดาทาวิถีการทำงานของตัวรันแบบฝังจะบันทึกข้อมูลประจำตัว {agentId, sessionId, sessionKey} แทนการจัดเก็บตัวระบุตำแหน่งทรานสคริปต์แบบถาวร

คงรายการต่อไปนี้ให้รองรับด้วยไฟล์ไว้ก่อน:

• openclaw.json
• ไฟล์ข้อมูลรับรองของผู้ให้บริการหรือ CLI
• ไฟล์แมนิเฟสต์ของ Plugin/แพ็กเกจ
• เวิร์กสเปซผู้ใช้และรีโพซิทอรี Git เมื่อเลือกโหมดดิสก์
• บันทึกที่มีไว้ให้ผู้ปฏิบัติงานติดตาม เว้นแต่จะมีการย้ายพื้นผิวบันทึกเฉพาะรายการ

แผนการย้ายข้อมูล

ระยะที่ 0: ตรึงขอบเขต

กำหนดขอบเขตสถานะถาวรให้ชัดเจนก่อนย้ายแถวเพิ่มเติม:

• เพิ่มตาราง migration_runs ไปยังฐานข้อมูลส่วนกลาง ดำเนินการแล้วสำหรับรายงานการดำเนินการย้ายข้อมูลสถานะเดิม
• เพิ่มบริการย้ายข้อมูลสถานะจากไฟล์ไปยังฐานข้อมูลเพียงรายการเดียวซึ่ง doctor เป็นเจ้าของ ดำเนินการแล้ว: openclaw doctor --fix ใช้การติดตั้งใช้งานการย้ายข้อมูลสถานะเดิม
• กำหนดให้ plan เป็นแบบอ่านอย่างเดียว และให้ apply สร้างข้อมูลสำรอง นำเข้า ตรวจสอบ แล้วจึงลบหรือกักกันไฟล์เก่า ดำเนินการแล้ว: doctor สร้างข้อมูลสำรองก่อนย้ายข้อมูลที่ผ่านการตรวจสอบ ส่งพาธข้อมูลสำรอง ไปยัง migration_runs และใช้พาธตัวนำเข้า/การลบซ้ำ
• เพิ่มข้อห้ามแบบสแตติกเพื่อไม่ให้โค้ดขณะรันไทม์ใหม่เขียนไฟล์สถานะเดิม ขณะที่ โค้ดการย้ายข้อมูลและการทดสอบยังคงสร้างข้อมูลตั้งต้น/อ่านไฟล์เหล่านั้นได้ ดำเนินการแล้วสำหรับพื้นที่จัดเก็บเดิมที่ย้ายข้อมูลในปัจจุบัน โดยตัวป้องกันจะสแกน การทดสอบที่ซ้อนกันเพื่อหาสัญญาตัวระบุตำแหน่งทรานสคริปต์ขณะรันไทม์ที่ต้องห้ามด้วย

ระยะที่ 1: ทำระนาบควบคุมส่วนกลางให้เสร็จสมบูรณ์

เก็บสถานะการประสานงานที่ใช้ร่วมกันไว้ใน state/openclaw.sqlite:

• เอเจนต์และรีจิสทรีฐานข้อมูลเอเจนต์
• บัญชีแยกประเภทงานและ Task Flow
• สถานะ Plugin
• รีจิสทรีคอนเทนเนอร์/เบราว์เซอร์ของแซนด์บ็อกซ์
• ประวัติการรัน Cron/ตัวกำหนดเวลา
• การจับคู่ อุปกรณ์ การพุช การตรวจสอบการอัปเดต TUI แคช OpenRouter/โมเดล และสถานะ ขณะรันไทม์ขนาดเล็กอื่นๆ ที่กำหนดขอบเขตตาม Gateway
• เมทาดาทาการสำรองข้อมูลและการย้ายข้อมูล
• ไบต์ไฟล์แนบสื่อของ Gateway ดำเนินการแล้วสำหรับการเขียนข้อมูลขณะรันไทม์ โดยพาธไฟล์โดยตรง เป็นการสร้างไฟล์ชั่วคราวเพื่อให้เข้ากันได้กับตัวส่งของช่องทางและการจัดเตรียม แซนด์บ็อกซ์ รายการอนุญาตขณะรันไทม์ยอมรับพาธการสร้างไฟล์จาก SQLite ไม่ใช่ราก สื่อสถานะ/การกำหนดค่าเดิม doctor จะนำเข้าไฟล์สื่อเดิมไปยัง media_blobs และลบไฟล์ต้นทางหลังเขียนแถวสำเร็จ
• เซสชัน เหตุการณ์ และบล็อบเพย์โหลดของการบันทึกพร็อกซีดีบัก ดำเนินการแล้ว: ข้อมูลที่บันทึก อยู่ในฐานข้อมูลสถานะที่ใช้ร่วมกัน และเปิดผ่านการบูตสแตรป สคีมา WAL และการตั้งค่าเวลารอเมื่อไม่ว่างของฐานข้อมูลสถานะที่ใช้ร่วมกัน ไบต์เพย์โหลดถูกบีบอัดด้วย gzip ใน capture_blobs.data ไม่มีการแทนที่ฐานข้อมูล sidecar ขณะรันไทม์ของพร็อกซีดีบัก ไดเรกทอรีบล็อบ หรือเป้าหมายสคีมา/การสร้างโค้ดที่สร้างขึ้นเฉพาะการบันทึกพร็อกซี การย้ายข้อมูลของ doctor/การเริ่มต้นจะนำเข้าแถว debug-proxy/capture.sqlite ที่เผยแพร่แล้ว และบล็อบเพย์โหลดที่อ้างอิง รวมถึงการแทนที่สภาพแวดล้อมฐานข้อมูล/บล็อบเดิมที่ใช้งานอยู่ จากนั้นเก็บแหล่งข้อมูลเหล่านั้นเข้าคลังโดยคงใบรับรอง CA ไว้ดังเดิม

ระยะนี้ยังลบตัวเปิด sidecar ที่ซ้ำกัน ตัวช่วยด้านสิทธิ์ การตั้งค่า WAL การตัดแต่งระบบไฟล์ และตัวเขียนเพื่อความเข้ากันได้ออกจากระบบย่อยเหล่านั้นด้วย

ระยะที่ 2: เริ่มใช้ฐานข้อมูลแยกตามเอเจนต์

สร้างฐานข้อมูลหนึ่งชุดต่อเอเจนต์ และลงทะเบียนจากฐานข้อมูลส่วนกลาง:

~/.openclaw/state/openclaw.sqlite~/.openclaw/agents/<agentId>/agent/openclaw-agent.sqlite

แถว agent_databases ส่วนกลางเก็บพาธ เวอร์ชันสคีมา การประทับเวลา ที่พบล่าสุด และข้อมูลเมตาพื้นฐานด้านขนาด/ความสมบูรณ์ โค้ดรันไทม์จะขอ ฐานข้อมูลเอเจนต์จากรีจิสทรี แทนการคำนวณพาธไฟล์โดยตรง

ฐานข้อมูลเอเจนต์เป็นเจ้าของ:

• sessions เป็นรากเซสชันมาตรฐาน โดยมี session_entries เป็น ตารางเพย์โหลดที่มีรูปแบบเพื่อความเข้ากันได้ซึ่งเชื่อมกับรากนั้น และ session_routes เป็นการค้นหา session_key ที่ใช้งานอยู่ซึ่งไม่ซ้ำกัน
• conversations และ session_conversations เป็นข้อมูลประจำตัวการกำหนดเส้นทาง ผู้ให้บริการแบบปรับให้อยู่ในรูปมาตรฐานซึ่งเชื่อมกับเซสชัน
• transcript_events
• สแนปช็อตทรานสคริปต์และเช็กพอยต์ Compaction ดำเนินการแล้วสำหรับการเขียนของรันไทม์
• vfs_entries
• tool_artifacts และอาร์ติแฟกต์การรัน
• แถวรันไทม์/แคชภายในเอเจนต์ ดำเนินการแล้วสำหรับแคชที่จำกัดขอบเขตตามเวิร์กเกอร์
• เหตุการณ์สตรีมแม่ของ ACP
• เหตุการณ์รันไทม์ของวิถีการทำงาน เมื่อไม่ได้เป็นอาร์ติแฟกต์ส่งออกที่ระบุไว้อย่างชัดเจน

ระยะที่ 3: แทนที่ API ของที่เก็บเซสชัน

ดำเนินการแล้วสำหรับรันไทม์ พื้นผิวที่เก็บเซสชันในรูปแบบไฟล์ไม่ใช่ สัญญารันไทม์ที่ใช้งานอยู่:

• รันไทม์ไม่เรียก loadSessionStore(storePath) หรือถือว่า storePath เป็น ข้อมูลประจำตัวเซสชันอีกต่อไป
• การดำเนินการกับแถวของรันไทม์คือ getSessionEntry, upsertSessionEntry, patchSessionEntry, deleteSessionEntry และ listSessionEntries
• ตัวช่วยเขียนที่เก็บใหม่ทั้งชุด ตัวเขียนไฟล์ การทดสอบคิว การตัดแต่งนามแฝง และ พารามิเตอร์การลบคีย์แบบเดิมถูกนำออกจากรันไทม์แล้ว
• การส่งออกเพื่อความเข้ากันได้จากแพ็กเกจรากที่เลิกแนะนำแล้วยังคงปรับ พาธ sessions.json มาตรฐานให้เข้ากับ API แถวของ SQLite
• การแยกวิเคราะห์ sessions.json คงอยู่เฉพาะในโค้ดย้ายข้อมูล/นำเข้าของ doctor และ การทดสอบ doctor
• การอ่านสำรองของวงจรชีวิตรันไทม์จะอ่านส่วนหัวทรานสคริปต์ของ SQLite ไม่ใช่ บรรทัดแรกของ JSONL

ให้ลบทุกสิ่งที่นำพารามิเตอร์ล็อกไฟล์ คำศัพท์การตัดแต่ง/ตัดทอนในฐานะการบำรุงรักษาไฟล์ ข้อมูลประจำตัวจากพาธที่เก็บ หรือการทดสอบ ที่ยืนยันเพียงการคงอยู่ของ JSON กลับมาใช้อีก

ระยะที่ 4: ย้ายทรานสคริปต์ สตรีม ACP วิถีการทำงาน และ VFS

ทำให้ทุกสตรีมข้อมูลของเอเจนต์ทำงานบนฐานข้อมูลโดยตรง:

• การเขียนแบบต่อท้ายทรานสคริปต์ดำเนินการผ่านธุรกรรม SQLite หนึ่งรายการ ซึ่งรับรองว่า มีส่วนหัวเซสชัน ตรวจสอบความเป็น idempotent ของข้อความ เลือกส่วนท้ายของแม่ แทรก ลงใน transcript_events และบันทึกข้อมูลเมตาข้อมูลประจำตัวที่สืบค้นได้ใน transcript_event_identities ดำเนินการแล้วสำหรับการต่อท้ายข้อความทรานสคริปต์โดยตรงและ การต่อท้าย TranscriptSessionManager แบบคงอยู่ตามปกติ การดำเนินการกับกิ่งที่ระบุชัดเจน จะยังคงใช้ตัวเลือกแม่ที่ระบุชัดเจน และยังเขียนแถว SQLite โดยไม่คำนวณตัวระบุตำแหน่งไฟล์ใดๆ
• บันทึกสตรีมแม่ของ ACP เปลี่ยนเป็นแถว ไม่ใช่ไฟล์ .acp-stream.jsonl ดำเนินการแล้ว
• การตั้งค่าการสร้าง ACP ไม่คงพาธ JSONL ของทรานสคริปต์อีกต่อไป ดำเนินการแล้ว
• การบันทึกวิถีการทำงานของรันไทม์เขียนแถวเหตุการณ์/อาร์ติแฟกต์โดยตรง คำสั่ง สนับสนุน/ส่งออกที่ระบุชัดเจนยังคงสร้างอาร์ติแฟกต์ JSONL ของชุดข้อมูลสนับสนุนเป็น รูปแบบส่งออกได้ แต่การส่งออกเซสชันจะไม่สร้าง JSONL ของเซสชันขึ้นใหม่ ดำเนินการแล้ว
• พื้นที่ทำงานบนดิสก์จะคงอยู่บนดิสก์เมื่อกำหนดค่าเป็นโหมดดิสก์
• พื้นที่ชั่วคราวของ VFS และโหมดพื้นที่ทำงานเฉพาะ VFS แบบทดลองใช้ฐานข้อมูลเอเจนต์

การย้ายข้อมูลจะนำเข้าไฟล์ JSONL เก่าเพียงครั้งเดียว บันทึกจำนวน/แฮชไว้ใน migration_runs และลบไฟล์ที่นำเข้าแล้วหลังการตรวจสอบความสมบูรณ์

ระยะที่ 5: สำรองข้อมูล กู้คืน Vacuum และตรวจสอบ

ข้อมูลสำรองยังคงเป็นไฟล์เก็บถาวรหนึ่งไฟล์:

• สร้างเช็กพอยต์ให้ฐานข้อมูลส่วนกลางและฐานข้อมูลเอเจนต์ทุกชุด
• สร้างสแนปช็อตของแต่ละฐานข้อมูลด้วยความหมายการสำรองข้อมูลของ SQLite หรือ VACUUM INTO
• เก็บสแนปช็อตฐานข้อมูลแบบกะทัดรัด การกำหนดค่า ข้อมูลประจำตัวภายนอก และการส่งออก พื้นที่ทำงานที่ร้องขอไว้ในไฟล์เก็บถาวร
• ไม่รวมไฟล์สดดิบ *.sqlite-wal และ *.sqlite-shm
• ตรวจสอบโดยเปิดสแนปช็อตฐานข้อมูลทุกชุดและเรียกใช้ PRAGMA integrity_check openclaw backup create จะตรวจสอบไฟล์เก็บถาวรนี้โดยค่าเริ่มต้น --no-verify จะข้ามเฉพาะขั้นตอนตรวจสอบไฟล์เก็บถาวรหลังการเขียน ไม่ใช่การตรวจสอบ ความสมบูรณ์ของการสร้างสแนปช็อต
• การกู้คืนจะคัดลอกสแนปช็อตกลับไปยังพาธเป้าหมาย ฐานข้อมูลส่วนกลางที่กู้คืนใช้ เวอร์ชัน 1; ฐานข้อมูลแยกตามเอเจนต์ที่กู้คืนใช้เวอร์ชัน 2 โดยสแนปช็อตเวอร์ชัน 1 จะได้รับการอัปเกรดแบบอะตอมเมื่อเปิด

ระยะที่ 6: รันไทม์เวิร์กเกอร์

คงโหมดเวิร์กเกอร์ไว้เป็นฟีเจอร์ทดลองระหว่างการนำการแยกฐานข้อมูลมาใช้:

• เวิร์กเกอร์จะได้รับรหัสเอเจนต์ รหัสการรัน โหมดระบบไฟล์ และข้อมูลประจำตัวรีจิสทรีฐานข้อมูล
• เวิร์กเกอร์แต่ละตัวเปิดการเชื่อมต่อ SQLite ของตนเอง
• แม่ยังคงมีอำนาจในการส่งผ่านช่องทาง การอนุมัติ การกำหนดค่า และการยกเลิก
• เริ่มจากเวิร์กเกอร์หนึ่งตัวต่อการรันที่ใช้งานอยู่ เพิ่มพูลหลังจากความเป็นเจ้าของ วงจรชีวิตและการเชื่อมต่อฐานข้อมูลมีเสถียรภาพแล้วเท่านั้น

ระยะที่ 7: ลบโลกแบบเก่า

ดำเนินการแล้วสำหรับการจัดการเซสชันของรันไทม์ โลกแบบเก่าอนุญาตให้ใช้ได้เฉพาะเป็น อินพุตของ doctor หรือเอาต์พุตการสนับสนุน/ส่งออกที่ระบุชัดเจน:

• ไม่มีการเขียน sessions.json ของรันไทม์, JSONL ของทรานสคริปต์, JSON ของรีจิสทรีแซนด์บ็อกซ์, SQLite แบบ sidecar ของงาน หรือ SQLite แบบ sidecar ของสถานะ Plugin
• ไม่มีการตัดแต่งไฟล์ JSON/เซสชัน การตัดทอนไฟล์ทรานสคริปต์ ล็อกไฟล์เซสชัน หรือการทดสอบเซสชันที่มีรูปแบบเป็นล็อก
• ไม่มีการส่งออกเพื่อความเข้ากันได้ของรันไทม์ที่มีจุดประสงค์เพื่อทำให้ไฟล์เซสชันเก่า เป็นปัจจุบันอยู่เสมอ
• การส่งออกข้อมูลสนับสนุนที่ระบุชัดเจนยังคงเป็นรูปแบบไฟล์เก็บถาวร/การทำให้เป็นรูปธรรม ที่ผู้ใช้ร้องขอ และต้องไม่ส่งชื่อไฟล์กลับเข้าไปในข้อมูลประจำตัวของรันไทม์

การสำรองและกู้คืน

ข้อมูลสำรองควรเป็นไฟล์เก็บถาวรหนึ่งไฟล์ แต่การบันทึกฐานข้อมูลควรใช้ กลไกของ SQLite โดยตรง:

1. หยุดกิจกรรมการเขียนที่ใช้เวลานาน หรือเข้าสู่แนวกั้นการสำรองข้อมูลช่วงสั้นๆ
2. เรียกใช้เช็กพอยต์สำหรับฐานข้อมูลส่วนกลางและฐานข้อมูลเอเจนต์ทุกชุด
3. สร้างสแนปช็อตฐานข้อมูลด้วย VACUUM INTO ลงในไดเรกทอรีสำรองข้อมูลชั่วคราว สคีมา Plugin ที่ต้องใช้ความสามารถ SQLite ซึ่งเจ้าของกำหนดจะปฏิเสธการทำงานโดยค่าเริ่มต้น จนกว่าเจ้าของจะจัดทำสัญญาสแนปช็อตที่ปลอดภัย
4. เก็บสแนปช็อตฐานข้อมูล ไฟล์การกำหนดค่า ไดเรกทอรีข้อมูลประจำตัว พื้นที่ทำงาน ที่เลือก และไฟล์รายการไว้ในไฟล์เก็บถาวร
5. ตรวจสอบรูปแบบไฟล์ของสแนปช็อต SQLite ทุกชุด จากนั้นเปิดฐานข้อมูล OpenClaw มาตรฐานและเรียกใช้ PRAGMA integrity_check พร้อมการตรวจสอบบทบาท สคีมา Plugin แบบเฉพาะยังคงเป็นแบบทึบ เว้นแต่เจ้าของจะจัดเตรียมตัวตรวจสอบ openclaw backup create จะดำเนินการนี้โดยค่าเริ่มต้น ส่วน --no-verify ใช้เฉพาะ เมื่อตั้งใจข้ามขั้นตอนตรวจสอบไฟล์เก็บถาวรหลังการเขียน

อย่าใช้สำเนาไฟล์สดดิบ *.sqlite, *.sqlite-wal และ *.sqlite-shm เป็นรูปแบบสำรองข้อมูลหลัก ไฟล์รายการของไฟล์เก็บถาวรควรบันทึกบทบาทฐานข้อมูล รหัสเอเจนต์ เวอร์ชันสคีมา พาธต้นทาง พาธสแนปช็อต ขนาดเป็นไบต์ และสถานะ ความสมบูรณ์

การกู้คืนควรสร้างไฟล์ฐานข้อมูลส่วนกลางและฐานข้อมูลเอเจนต์ขึ้นใหม่จาก สแนปช็อตในไฟล์เก็บถาวร สคีมาส่วนกลางยังคงเป็นเวอร์ชัน 1; สแนปช็อตแยกตามเอเจนต์เวอร์ชัน 1 จะได้รับการอัปเกรดรันไทม์แบบจำกัดขอบเขตเป็นเวอร์ชัน 2 Doctor ยังคงเป็น เจ้าของเพียงรายเดียวของการนำเข้าจากไฟล์สู่ฐานข้อมูล คำสั่งกู้คืนจะตรวจสอบ ไฟล์เก็บถาวรก่อน จากนั้นแทนที่แอสเซ็ตแต่ละรายการในไฟล์รายการด้วยเพย์โหลด ที่แตกไฟล์และผ่านการตรวจสอบแล้ว

แผนปรับโครงสร้างรันไทม์

1. เพิ่ม API รีจิสทรีฐานข้อมูล

   • แก้ไขพาธฐานข้อมูลส่วนกลางและฐานข้อมูลแยกตามเอเจนต์
   • คงสคีมาส่วนกลางไว้ที่ user_version = 1 ฐานข้อมูลแยกตามเอเจนต์ใช้เวอร์ชัน 2 พร้อมการย้ายข้อมูลแบบอะตอมหนึ่งครั้งจากรูปแบบแหล่งข้อมูลหน่วยความจำเวอร์ชัน 1 ที่เผยแพร่แล้ว
   • เพิ่มตัวช่วยปิด/เช็กพอยต์/ตรวจสอบความสมบูรณ์ที่ใช้โดยการทดสอบ การสำรองข้อมูล และ doctor

2. รวมที่เก็บ SQLite แบบ sidecar

   • ย้ายตารางสถานะ Plugin ไปยังฐานข้อมูลส่วนกลาง ดำเนินการแล้วสำหรับการเขียนของรันไทม์ ตัวนำเข้า sidecar แบบเดิมที่ยังไม่เผยแพร่ถูกลบแล้ว
   • ย้ายตารางรีจิสทรีงานไปยังฐานข้อมูลส่วนกลาง ดำเนินการแล้วสำหรับการเขียนของรันไทม์ ตัวนำเข้า sidecar แบบเดิมที่ยังไม่เผยแพร่ถูกลบแล้ว
   • ย้ายตาราง Task Flow ไปยังฐานข้อมูลส่วนกลาง ดำเนินการแล้วสำหรับการเขียนของรันไทม์ ตัวนำเข้า sidecar แบบเดิมที่ยังไม่เผยแพร่ถูกลบแล้ว
   • ย้ายตารางค้นหาหน่วยความจำในตัวไปยังฐานข้อมูลเอเจนต์แต่ละชุด ดำเนินการแล้ว; ตอนนี้ doctor จะนำ memorySearch.store.path แบบกำหนดเองที่ระบุชัดเจนออกผ่านการย้ายข้อมูลการกำหนดค่า การทำดัชนีใหม่ทั้งหมดทำงานกับตารางหน่วยความจำโดยตรงเท่านั้น พาธสลับไฟล์ทั้งชุด แบบเก่าและตัวช่วยสลับดัชนี sidecar ถูกลบแล้ว
   • ลบตัวเปิดฐานข้อมูล การตั้งค่า WAL ตัวช่วยด้านสิทธิ์ และ พาธการปิดที่ซ้ำกันออกจากระบบย่อยเหล่านั้น

3. ย้ายตารางที่เอเจนต์เป็นเจ้าของไปยังฐานข้อมูลแยกตามเอเจนต์

   • สร้างฐานข้อมูลเอเจนต์ตามความต้องการผ่านรีจิสทรีฐานข้อมูลส่วนกลาง ดำเนินการแล้ว
   • ย้ายรายการเซสชันรันไทม์ เหตุการณ์ทรานสคริปต์ แถว VFS และอาร์ติแฟกต์เครื่องมือ ไปยังฐานข้อมูลเอเจนต์ ดำเนินการแล้ว
   • อย่าย้ายรายการเซสชัน เหตุการณ์ทรานสคริปต์ แถว VFS หรืออาร์ติแฟกต์เครื่องมือ ในฐานข้อมูลร่วมเฉพาะกิ่ง เพราะเลย์เอาต์นั้นไม่เคยเผยแพร่ ให้คงไว้เฉพาะ การนำเข้าจากไฟล์สู่ฐานข้อมูลแบบเดิมใน doctor

4. แทนที่ API ของที่เก็บเซสชัน

   • นำ storePath ออกจากการเป็นข้อมูลประจำตัวรันไทม์ ดำเนินการแล้วสำหรับรันไทม์และมี check:database-first-legacy-stores ป้องกันไว้: ข้อมูลเมตาเซสชัน การอัปเดตเส้นทาง การคงคำสั่ง การล้างเซสชันของ CLI ตัวอย่างการให้เหตุผลของ Feishu การคงสถานะทรานสคริปต์ ความลึกของเอเจนต์ย่อย การเขียนทับเซสชันของโปรไฟล์ การยืนยันตัวตน ตรรกะการแยกกิ่งจากแม่ และการตรวจสอบ QA-lab ขณะนี้แก้ไข ฐานข้อมูลจากคีย์เอเจนต์/เซสชันมาตรฐาน การตอบกลับรายการเซสชันของ Gateway/TUI/UI/macOS แสดง databasePath แทน path แบบเดิมแล้ว ส่วนพื้นผิวดีบักของ macOS แสดงฐานข้อมูลแยกตามเอเจนต์ เป็นสถานะแบบอ่านอย่างเดียว แทนการเขียนการกำหนดค่า session.store /status การส่งออกวิถีการทำงานที่ขับเคลื่อนด้วยแชต และพร็อกซีการขึ้นต่อกันของ CLI ไม่เผยแพร่พาธที่เก็บแบบเดิมอีกต่อไป การอ่านสำรองการใช้งานทรานสคริปต์จะอ่าน SQLite ตามข้อมูลประจำตัวเอเจนต์/เซสชัน การทดสอบรันไทม์และบริดจ์ไม่แสดง storePath อีกต่อไป อินพุต doctor/การย้ายข้อมูลเป็นเจ้าของชื่อฟิลด์แบบเดิมนั้น การโหลดเซสชันรวมของ Gateway ไม่มีกิ่งรันไทม์พิเศษสำหรับค่า session.store ที่ไม่ได้ใช้เทมเพลตอีกต่อไป แต่จะรวมแถว SQLite แยกตามเอเจนต์ เลน doctor สำหรับล็อกเซสชันแบบเดิมและตัวช่วยล้างข้อมูล .jsonl.lock ถูกนำออกแล้ว ขณะนี้ SQLite เป็นขอบเขตการทำงานพร้อมกันของเซสชัน จุดเรียกใช้รันไทม์ที่ใช้บ่อยใช้ชื่อตัวช่วยแบบแถว เช่น resolveSessionRowEntry; นามแฝงเพื่อความเข้ากันได้ resolveSessionStoreEntry แบบเก่า ถูกนำออกจากการส่งออกรันไทม์และ Plugin SDK แล้ว

• ใช้การดำเนินการแถว { agentId, sessionKey } ดำเนินการแล้ว: getSessionEntry, upsertSessionEntry, deleteSessionEntry, patchSessionEntry และ listSessionEntries เป็น API ที่ใช้ SQLite ก่อน ซึ่ง ไม่ต้องใช้พาธที่เก็บเซสชัน สรุปสถานะ สถานะเอเจนต์ภายในเครื่อง สถานภาพ และคำสั่งแสดงรายการ openclaw sessions จะอ่านแถวแยกตามเอเจนต์โดยตรง และแสดงพาธฐานข้อมูล SQLite แยกตามเอเจนต์ แทนพาธ sessions.json
• แทนที่การลบ/แทรกทั้งที่เก็บด้วย upsertSessionEntry, deleteSessionEntry, listSessionEntries และคิวรีล้างข้อมูล SQL ดำเนินการแล้วสำหรับรันไทม์: ขณะนี้พาธที่ใช้บ่อยใช้ API แถวและแพตช์แถวที่ลองใหม่ เมื่อเกิดข้อขัดแย้ง ส่วนตัวช่วยนำเข้า/แทนที่ทั้งที่เก็บที่เหลือจำกัดไว้เฉพาะ โค้ดนำเข้าการย้ายข้อมูลและการทดสอบแบ็กเอนด์ SQLite
  • ลบ store-writer.ts และการทดสอบคิวตัวเขียน ดำเนินการแล้ว
  • ลบการตัดแต่งคีย์แบบเดิมของรันไทม์และพารามิเตอร์ลบนามแฝงออกจากการ upsert/แพตช์แถวเซสชัน ดำเนินการแล้ว

5. ลบพฤติกรรมรีจิสทรี JSON ขณะรันไทม์
   • กำหนดให้การอ่านและเขียนรีจิสทรี sandbox ใช้ SQLite เท่านั้น เสร็จแล้ว
   • นำเข้า JSON แบบไฟล์เดียวและแบบแบ่งส่วนเฉพาะจากขั้นตอนการย้ายข้อมูลเท่านั้น เสร็จแล้ว
   • ลบล็อกของรีจิสทรีแบบแบ่งส่วนและการเขียน JSON เสร็จแล้ว

• ใช้ตารางรีจิสทรีแบบมีชนิดเพียงตารางเดียว แทนการจัดเก็บแถวรีจิสทรีเป็น JSON ทั่วไป ที่ไม่เปิดเผยโครงสร้าง หากรูปแบบดังกล่าวยังคงเป็นสถานะการทำงานในเส้นทางประมวลผลสำคัญ เสร็จแล้ว

6. ลบการเปลี่ยนแปลงเซสชันที่มีรูปแบบคล้ายการล็อกไฟล์

   • เสร็จแล้วสำหรับการสร้างล็อกขณะรันไทม์และ API ล็อกขณะรันไทม์
   • ลบช่องทางการล้างข้อมูล doctor แบบดั้งเดิม .jsonl.lock ที่แยกต่างหากแล้ว
   • การตรวจสอบความสมบูรณ์ของสถานะไม่มีเส้นทางแยกต่างหากสำหรับตัดไฟล์ทรานสคริปต์ ที่ไม่มีเจ้าของอีกต่อไป การย้ายข้อมูลของ doctor จะนำเข้า/ลบแหล่งข้อมูล JSONL แบบดั้งเดิมในจุดเดียว
   • การประสานงานอินสแตนซ์เดี่ยวของ Gateway ใช้แถว SQLite แบบมีชนิด state_leases ภายใต้ gateway_locks และไม่เปิดเผยจุดเชื่อมต่อไดเรกทอรีล็อกไฟล์อีกต่อไป
   • การคงสถานะการขจัดข้อมูลซ้ำของ plugin SDK ทั่วไปไม่ใช้ล็อกไฟล์หรือไฟล์ JSON อีกต่อไป แต่เขียนแถวสถานะ Plugin ลงใน SQLite ที่ใช้ร่วมกัน เสร็จแล้ว
   • การประสานงาน QMD ใช้ลีส SQLite ที่ใช้ร่วมกันสำหรับการฝังข้อมูล และลีส SQLite ต่อเอเจนต์สำหรับตัวเขียนคอลเลกชัน/การอัปเดต/การฝังข้อมูลทุกรายการ รันไทม์ไม่สร้าง qmd/embed.lock.lock หรือ agents/<agentId>/qmd-write.lock.lock อีกต่อไป Doctor จะลบเฉพาะไฟล์ข้างเคียงที่เลิกใช้แล้วและเก่าแน่นอนเท่านั้น เสร็จแล้ว

7. ทำให้เวิร์กเกอร์รับรู้ฐานข้อมูล

   • เวิร์กเกอร์เปิดการเชื่อมต่อ SQLite ของตนเอง
   • โพรเซสแม่เป็นเจ้าของการส่งมอบ คอลแบ็กของช่องทาง และการกำหนดค่า
   • เวิร์กเกอร์รับรหัสเอเจนต์ รหัสการรัน โหมดระบบไฟล์ และข้อมูลประจำตัวรีจิสทรี DB ไม่ใช่แฮนเดิลที่กำลังใช้งาน
   • vfs-only ยังคงเป็นคุณสมบัติทดลองและใช้ฐานข้อมูลเอเจนต์เป็นรากของพื้นที่จัดเก็บ
   • เริ่มต้นด้วยเวิร์กเกอร์หนึ่งตัวต่อการรันที่ทำงานอยู่ การทำพูลรอได้จนกว่าอายุการใช้งาน การเชื่อมต่อ DB และพฤติกรรมการยกเลิกจะไม่มีความซับซ้อน

8. การผสานรวมการสำรองข้อมูล

   • ทำให้ระบบสำรองข้อมูลสามารถสร้างสแนปช็อตฐานข้อมูลส่วนกลาง ฐานข้อมูลเอเจนต์ และฐานข้อมูล Plugin ด้วย VACUUM INTO เสร็จแล้วสำหรับไฟล์ *.sqlite ที่ค้นพบภายใต้แอสเซ็ตสถานะ ส่วนสคีมา Plugin ที่ต้องใช้ความสามารถของเจ้าของซึ่งไม่มีอยู่จะหยุดทำงานแบบปิดเพื่อความปลอดภัย
   • เพิ่มการตรวจสอบข้อมูลสำรองสำหรับความสมบูรณ์และข้อมูลประจำตัวสคีมาของ SQLite มาตรฐาน รวมถึงการตรวจสอบรูปแบบไฟล์ทั่วไปสำหรับสแนปช็อต Plugin แบบเฉพาะ เสร็จแล้วสำหรับ การสร้างข้อมูลสำรองและการตรวจสอบอาร์ไคฟ์เริ่มต้น
   • บันทึกข้อมูลเมตาของการรันสำรองข้อมูลใน SQLite เสร็จแล้วผ่านตาราง backup_runs ที่ใช้ร่วมกัน พร้อมพาธอาร์ไคฟ์ สถานะ และ JSON ของไฟล์กำกับ
   • เพิ่มการคืนค่าจากสแนปช็อตอาร์ไคฟ์ที่ผ่านการตรวจสอบ เสร็จแล้ว: openclaw backup restore ตรวจสอบก่อนแตกไฟล์ ใช้ไฟล์กำกับ ที่ทำให้เป็นมาตรฐานแล้วจากตัวตรวจสอบ รองรับ --dry-run และต้องมี --yes ก่อนแทนที่ พาธต้นทางที่บันทึกไว้
   • รวมการส่งออก VFS/พื้นที่ทำงานเฉพาะเมื่อมีการร้องขอเท่านั้น ห้ามส่งออก ข้อมูลภายในเซสชันเป็น JSON หรือ JSONL

9. ลบการทดสอบและโค้ดที่ล้าสมัย เสร็จแล้วสำหรับพื้นผิวเซสชันรันไทม์ที่ทราบ

• ลบการทดสอบที่ยืนยันว่ารันไทม์สร้าง sessions.json หรือไฟล์ทรานสคริปต์ JSONL เสร็จแล้วสำหรับพื้นที่จัดเก็บเซสชันหลัก แชต เหตุการณ์ทรานสคริปต์ของ Gateway การแสดงตัวอย่าง วงจรชีวิต การอัปเดตรายการเซสชันของคำสั่ง การรีเซ็ต/ติดตามการตอบกลับอัตโนมัติ และ ฟิกซ์เจอร์ Dreaming ของแกนหน่วยความจำ การกำหนดเส้นทางเป้าหมายการอนุมัติ การซ่อมแซมทรานสคริปต์ เซสชัน การซ่อมแซมสิทธิ์ความปลอดภัย การส่งออกวิถี และการส่งออกเซสชัน ขณะนี้การทดสอบทรานสคริปต์ Active Memory ตรวจสอบขอบเขต SQLite และยืนยันว่าไม่มีการสร้าง ไฟล์ JSONL ชั่วคราวหรือถาวร ลบการทดสอบถดถอยแบบเก่าของ Heartbeat สำหรับการตัดทรานสคริปต์แล้ว เนื่องจาก รันไทม์ไม่ตัดทอนทรานสคริปต์ JSONL อีกต่อไป การทดสอบเครื่องมือรายการเซสชันของเอเจนต์ไม่จำลองพาธ sessions.json แบบดั้งเดิม เป็นรูปแบบการตอบกลับของ Gateway อีกต่อไป การทดสอบแอป/UI/macOS ใช้ databasePath ขณะนี้การทดสอบการใช้งานทรานสคริปต์ /status เติมแถวทรานสคริปต์ SQLite โดยตรง แทนการเขียนไฟล์ JSONL ขณะนี้การทดสอบวงจรชีวิตเซสชันของ Gateway ใช้ตัวช่วยเติมข้อมูลทรานสคริปต์ SQLite โดยตรง รูปแบบฟิกซ์เจอร์ไฟล์เซสชันบรรทัดเดียวแบบเก่าถูกลบออกจากความครอบคลุม การรีเซ็ตและการลบแล้ว sessions.delete ไม่ส่งคืนฟิลด์ archived: [] จากยุคไฟล์อีกต่อไป การลบ รายงานเฉพาะผลการเปลี่ยนแปลงแถว ตัวเลือก deleteTranscript แบบเก่าก็ถูกลบแล้ว: การลบเซสชันจะลบราก sessions มาตรฐาน และปล่อยให้ SQLite ลบแถวทรานสคริปต์ สแนปช็อต และวิถีที่เซสชันเป็นเจ้าของแบบต่อเนื่อง ดังนั้นจึงไม่มีผู้เรียกใดทิ้งทรานสคริปต์ ที่ไม่มีเจ้าของไว้เบื้องหลังหรือลืมแขนงการล้างข้อมูลได้ ขณะนี้การทดสอบการบันทึกวิถีของกลไกบริบทอ่านแถว trajectory_runtime_events จากฐานข้อมูลเอเจนต์ที่แยกต่างหาก แทนการอ่าน session.trajectory.jsonl ขณะนี้สคริปต์เติมข้อมูลช่องทาง Docker MCP เติมแถว SQLite โดยตรง การเขียน sessions.json โดยตรงจำกัดไว้เฉพาะฟิกซ์เจอร์ doctor E2E ของ Tool Search Gateway อ่านหลักฐานการเรียกเครื่องมือจากแถวทรานสคริปต์ SQLite แทนการสแกนไฟล์ agents/<agentId>/sessions/*.jsonl ขณะนี้เหตุการณ์โฮสต์และแถวชั่วคราวของคลังเซสชันในแกนหน่วยความจำอยู่ในสถานะ Plugin ของ SQLite ที่ใช้ร่วมกัน โดย events.jsonl และ session-corpus/*.txt เป็นเพียงอินพุต การย้ายข้อมูล doctor แบบดั้งเดิมเท่านั้น แถวที่ใช้งานอยู่ใช้พาธเสมือน memory/session-ingestion/ ไม่ใช่ .dreams/session-corpus โมดูลซ่อมแซม Dreaming ของแกนหน่วยความจำแบบเก่า และการทดสอบ CLI/Gateway ของโมดูลนั้นถูกลบแล้ว เนื่องจากรันไทม์ไม่ได้เป็นเจ้าของ การซ่อมแซมอาร์ไคฟ์ไฟล์สำหรับคลังดังกล่าวอีกต่อไป การทดสอบบริดจ์/อาร์ติแฟกต์สาธารณะ ของแกนหน่วยความจำไม่แสดง .dreams/events.jsonl อีกต่อไป แต่ใช้ชื่ออาร์ติแฟกต์ JSON เสมือน ที่มี SQLite เป็นแบ็กเอนด์ ขณะนี้เอกสารการทดสอบ SDK/Codex สาธารณะระบุว่าสถานะเซสชัน SQLite แทนไฟล์เซสชัน และตัวอย่างรอบการทำงานของช่องทางไม่เปิดเผยอาร์กิวเมนต์ storePath อีกต่อไป ขณะนี้สถานะการซิงค์ Matrix ใช้พื้นที่จัดเก็บสถานะ Plugin ของ SQLite โดยตรง สัญญา ไคลเอ็นต์/รันไทม์ที่ใช้งานอยู่ส่งรากพื้นที่จัดเก็บของบัญชี ไม่ใช่พาธ bot-storage.json และ doctor จะนำเข้า bot-storage.json แบบดั้งเดิมลงใน SQLite ก่อนลบต้นทาง ขณะนี้สถานการณ์การรีสตาร์ต/ทำลายข้อมูล Matrix ใน QA Lab เปลี่ยนแปลงแถวการซิงค์ SQLite โดยตรง แทนการสร้างหรือลบไฟล์ bot-storage.json ปลอม และชั้นพื้นฐาน E2EE ส่งราก พื้นที่จัดเก็บการซิงค์แทนพาธ sync-store.json ปลอม การเลือกรากพื้นที่จัดเก็บ Matrix ไม่ให้คะแนนรากตามไฟล์ JSON การซิงค์/เธรดแบบดั้งเดิม อีกต่อไป แต่ใช้ข้อมูลเมตาของรากที่คงทนร่วมกับสถานะการเข้ารหัสจริง ชุดทดสอบแบ็กเอนด์เซสชัน SQLite ขณะรันไทม์ไม่สร้าง sessions.json ปลอมอีกต่อไป ขณะนี้ฟิกซ์เจอร์ต้นทางแบบดั้งเดิมอยู่ในการทดสอบ doctor ที่นำเข้าฟิกซ์เจอร์เหล่านั้น การทดสอบเซสชัน Gateway ไม่เปิดเผยตัวช่วย createSessionStoreDir หรือการตั้งค่าพาธ พื้นที่จัดเก็บเซสชันชั่วคราวที่ไม่ได้ใช้อีกต่อไป ไดเรกทอรีฟิกซ์เจอร์ระบุอย่างชัดเจน และการตั้งค่าแถวโดยตรงใช้การตั้งชื่อแถวเซสชัน SQLite ย้ายความครอบคลุมตัวแยกวิเคราะห์พื้นที่จัดเก็บเซสชัน JSON5 ที่ใช้เฉพาะ doctor ออกจากการทดสอบโครงสร้างพื้นฐานไปยังการทดสอบการย้ายข้อมูล doctor แล้ว ดังนั้น ชุดทดสอบรันไทม์จึงไม่เป็นเจ้าของการแยกวิเคราะห์ไฟล์เซสชันแบบดั้งเดิมอีกต่อไป การทดสอบ SSO/การอัปโหลดที่รอดำเนินการขณะรันไทม์ของ Microsoft Teams ไม่พกฟิกซ์เจอร์ หรือโปรแกรมแยกวิเคราะห์ไฟล์ JSON ข้างเคียงอีกต่อไป การแยกวิเคราะห์โทเค็น SSO แบบดั้งเดิม อยู่เฉพาะในโมดูลการย้ายข้อมูลของ Plugin การทดสอบ Telegram ไม่เติมพาธพื้นที่จัดเก็บ /tmp/*.json ปลอมอีกต่อไป แต่รีเซ็ตแคชข้อความที่มี SQLite เป็นแบ็กเอนด์โดยตรง ตัวช่วยสถานะการทดสอบทั่วไปของ OpenClaw ไม่เปิดเผยตัวเขียน auth-profiles.json แบบดั้งเดิมอีกต่อไป โดยการทดสอบการย้ายข้อมูลการยืนยันตัวตนของ doctor เป็นเจ้าของ ฟิกซ์เจอร์ดังกล่าวภายใน การทดสอบรันไทม์สำหรับตัวชี้เซสชันล่าสุดของ TUI การอนุมัติการดำเนินการ สวิตช์ Active Memory การตรวจสอบการขจัดข้อมูลซ้ำ/การเริ่มต้นของ Matrix การซิงค์ต้นทาง Memory Wiki การผูกการสนทนาปัจจุบัน การยืนยันตัวตนระหว่างการเริ่มใช้งาน และการนำเข้าข้อมูลลับ Hermes ไม่สร้างไฟล์ข้างเคียงแบบเก่าหรือยืนยันว่าชื่อไฟล์เก่าไม่มีอยู่อีกต่อไป แต่พิสูจน์พฤติกรรม ผ่านแถว SQLite และ API พื้นที่จัดเก็บสาธารณะ การทดสอบ doctor/การย้ายข้อมูลเป็นเพียง ตำแหน่งเดียวที่ควรมีชื่อไฟล์ต้นทางแบบดั้งเดิม การทดสอบรันไทม์สำหรับการจับคู่อุปกรณ์/Node, allowFrom ของช่องทาง, เจตนาการรีสตาร์ต, การส่งต่อเมื่อรีสตาร์ต, รายการคิวส่งมอบเซสชัน, สถานะการกำหนดค่า, แคช iMessage, งาน Cron, ส่วนหัวทรานสคริปต์ PI, รีจิสทรีซับเอเจนต์ และไฟล์แนบรูปภาพที่มีการจัดการ ก็ไม่สร้างไฟล์ JSON/JSONL ที่เลิกใช้แล้วเพียงเพื่อพิสูจน์ว่าไฟล์เหล่านั้นถูกละเว้น หรือไม่มีอยู่อีกต่อไป การกู้คืน PI จากข้อมูลล้นไม่มีทางเลือกสำรองในการเขียนใหม่/ตัดทอนด้วย SessionManager อีกต่อไป การตัดทอนผลลัพธ์เครื่องมือและการเขียนทรานสคริปต์ใหม่ของกลไกบริบทจะเปลี่ยนแปลง แถวทรานสคริปต์ SQLite แล้วรีเฟรชสถานะพรอมต์ที่ใช้งานอยู่จากฐานข้อมูล การเพิ่มข้อความถาวรของ SessionManager มอบหมายให้ตัวช่วยเพิ่มทรานสคริปต์ SQLite แบบอะตอมจัดการการเลือกพาเรนต์และความสามารถในการทำซ้ำโดยไม่เกิดผลข้างเคียง การเพิ่มรายการเมตาดาต้า/กำหนดเองตามปกติจะเลือกพาเรนต์ปัจจุบันภายใน SQLite เช่นกัน เพื่อให้อินสแตนซ์ตัวจัดการที่ล้าสมัยไม่ทำให้การแข่งขันในเชนพาเรนต์ก่อน SQLite กลับมาอีก ขณะนี้การล้างส่วนท้าย PI สังเคราะห์สำหรับการตรวจสอบก่อนระหว่างรอบและ sessions_yield ตัดสถานะทรานสคริปต์ SQLite โดยตรง บริดจ์ลบส่วนท้ายของ SessionManager แบบเก่า และการทดสอบของบริดจ์ถูกลบแล้ว การบันทึกจุดตรวจสอบ Compaction ก็สร้างสแนปช็อตจาก SQLite เท่านั้น ผู้เรียกไม่ส่ง SessionManager ที่กำลังใช้งานเป็นแหล่งทรานสคริปต์ทางเลือกอีกต่อไป

• เก็บการทดสอบที่เติมไฟล์แบบดั้งเดิมไว้เฉพาะสำหรับการย้ายข้อมูล

• แทนที่หลักฐานจากไฟล์ JSON ด้วยหลักฐานจากแถว SQL สำหรับพื้นผิวรันไทม์ ที่ใช้งานอยู่แล้ว

• เพิ่มข้อห้ามแบบคงที่สำหรับการเขียนขณะรันไทม์ไปยังพาธ JSON ของเซสชัน/แคชแบบดั้งเดิม เสร็จแล้วสำหรับตัวป้องกันของรีโพ

10. ทำให้รายงานการย้ายข้อมูลตรวจสอบย้อนหลังได้
    • บันทึกการรันการย้ายข้อมูลใน SQLite พร้อมเวลาประทับเริ่มต้น/สิ้นสุด พาธต้นทาง แฮชต้นทาง จำนวน คำเตือน และพาธข้อมูลสำรอง เสร็จแล้ว: ขณะนี้การดำเนินการย้ายสถานะแบบดั้งเดิมบันทึกรายงาน migration_runs อย่างถาวร พร้อมบัญชีรายการพาธ/ตารางต้นทาง, SHA-256 ของไฟล์ต้นทาง, ขนาด, จำนวนเรคคอร์ด, คำเตือน และพาธข้อมูลสำรอง เสร็จแล้ว: การดำเนินการย้ายสถานะแบบดั้งเดิมยังบันทึกแถว migration_sources อย่างถาวร เพื่อการตรวจสอบระดับต้นทางและการตัดสินใจข้าม/เติมย้อนหลังในอนาคต
    • ทำให้การนำไปใช้สามารถทำซ้ำได้โดยไม่เกิดผลข้างเคียง การรันซ้ำหลังจากนำเข้าเพียงบางส่วน ควรข้ามต้นทางที่นำเข้าแล้วหรือผสานตามคีย์ที่เสถียร เสร็จแล้ว: ดัชนีเซสชัน ทรานสคริปต์ คิวส่งมอบ สถานะ Plugin บัญชีแยกประเภทงาน และแถว SQLite ส่วนกลางที่เอเจนต์เป็นเจ้าของ จะนำเข้าผ่านคีย์ที่เสถียรหรือ ความหมายแบบ upsert/replace ดังนั้นการรันซ้ำจึงผสานโดยไม่สร้างแถวถาวรซ้ำ
    • การนำเข้าที่ล้มเหลวต้องเก็บไฟล์ต้นทางเดิมไว้ที่ตำแหน่งเดิม เสร็จแล้ว: ขณะนี้การนำเข้าทรานสคริปต์ที่ล้มเหลวจะคงต้นทาง JSONL เดิมไว้ที่ พาธที่ตรวจพบ และ migration_sources จะบันทึกต้นทางเป็น warning พร้อม removed_source=0 สำหรับการรัน doctor ครั้งถัดไป

กฎด้านประสิทธิภาพ

• ใช้การเชื่อมต่อหนึ่งรายการต่อเธรด/โพรเซสได้ ห้ามใช้แฮนเดิลร่วมกันระหว่าง เวิร์กเกอร์
• ใช้ WAL, foreign_keys=ON, ระยะหมดเวลารอเมื่อไม่ว่าง 5 วินาที และทรานแซกชันการเขียน BEGIN IMMEDIATE แบบสั้น ห้ามวางการลองล็อกซ้ำแบบซิงโครนัสซ้อนเหนือการรอเมื่อไม่ว่าง เพียงครั้งเดียวของ SQLite
• ให้ตัวช่วยทรานแซกชันการเขียนทำงานแบบซิงโครนัสต่อไป เว้นแต่/จนกว่า API ทรานแซกชัน แบบอะซิงโครนัสจะเพิ่มความหมายของมิวเท็กซ์/แรงดันย้อนกลับอย่างชัดเจน
• รักษาการเขียนการส่งมอบของโพรเซสแม่ให้มีขนาดเล็กและอยู่ภายในทรานแซกชัน
• หลีกเลี่ยงการเขียนพื้นที่จัดเก็บทั้งหมดใหม่ ให้ใช้ upsert/delete ระดับแถว
• เพิ่มดัชนีสำหรับพาธการแสดงรายการตามเอเจนต์ การแสดงรายการตามเซสชัน เวลาที่อัปเดต รหัสการรัน และการหมดอายุ ก่อนย้ายโค้ดในเส้นทางประมวลผลสำคัญ
• จัดเก็บอาร์ติแฟกต์ขนาดใหญ่ สื่อ และเวกเตอร์เป็น BLOB หรือแถว BLOB แบบแบ่งส่วน ไม่ใช่ JSON แบบ base64 หรืออาร์เรย์ตัวเลข
• เก็บรายการสถานะ Plugin ที่ไม่เปิดเผยโครงสร้างให้มีขนาดเล็กและมีขอบเขตจำกัด
• เพิ่มการล้างข้อมูลด้วย SQL สำหรับ TTL/การหมดอายุแทนการตัดแต่งระบบไฟล์ เสร็จแล้วสำหรับพื้นที่จัดเก็บรันไทม์ที่ฐานข้อมูลเป็นเจ้าของ: สื่อ สถานะ Plugin, BLOB ของ Plugin, การขจัดข้อมูลซ้ำแบบถาวร และแคชเอเจนต์ ทั้งหมดหมดอายุผ่านแถว SQLite การล้างระบบไฟล์ ที่เหลือจำกัดไว้เฉพาะการสร้างไฟล์ชั่วคราวหรือคำสั่งลบที่ระบุอย่างชัดเจน

ข้อห้ามแบบคงที่

เพิ่มการตรวจสอบรีโพที่ล้มเหลวเมื่อมีการเขียนขณะรันไทม์ใหม่ไปยังพาธสถานะแบบดั้งเดิม:

• sessions.json
• *.trajectory.jsonl ยกเว้นเอาต์พุตชุดข้อมูลสนับสนุนที่สร้างขึ้นจริง
• .acp-stream.jsonl
• acp/event-ledger.json
• cache/*.json ไฟล์แคชรันไทม์
• agents/<agentId>/agent/auth.json
• agents/<agentId>/agent/models.json
• credentials/oauth.json
• github-copilot.token.json
• openrouter-models.json
• auth-profiles.json
• auth-state.json
• exec-approvals.json
• openclaw-workspace-state.json
• workspace-state.json
• workspace-attestations/*.attested
• รายการระดับเดียวกัน <workspace>.attested
• Matrix credentials*.json และ recovery-key.json
• cron/runs/*.jsonl
• cron/jobs.json
• jobs-state.json
• device-pair-notify.json
• devices/pending.json / devices/paired.json / devices/bootstrap.json (เลิกใช้เมื่อ 2026.7: ที่เก็บรันไทม์คือ device_pairing_* / device_bootstrap_tokens ในฐานข้อมูลสถานะที่ใช้ร่วมกัน; ระเบียนที่จับคู่จะถูกนำเข้าเมื่อ Gateway เริ่มทำงาน ส่วนแถว pending/bootstrap ชั่วคราวจะถูกทิ้ง)
• nodes/pending.json / nodes/paired.json (เลิกใช้เมื่อ 2026.7: รวมไว้ในระเบียนอุปกรณ์ที่จับคู่เมื่อ Gateway เริ่มทำงาน)
• identity/device.json
• identity/device-auth.json
• push/web-push-subscriptions.json (เลิกใช้แล้ว; นำเข้าเฉพาะผ่าน Doctor ไปยัง web_push_subscriptions)
• push/vapid-keys.json (เลิกใช้แล้ว; นำเข้าเฉพาะผ่าน Doctor ไปยัง web_push_vapid_keys)
• push/apns-registrations.json (เลิกใช้แล้ว; นำเข้าเฉพาะผ่าน Doctor ไปยัง apns_registrations)
• process-leases.json
• gateway-instance-id
• session-toggles.json
• Memory-core .dreams/events.jsonl
• Memory-core .dreams/session-corpus/
• Memory-core .dreams/daily-ingestion.json
• Memory-core .dreams/session-ingestion.json
• Memory-core .dreams/short-term-recall.json
• Memory-core .dreams/phase-signals.json
• Memory-core .dreams/short-term-promotion.lock
• Skill Workshop skill-workshop/<workspace>.json
• Skill Workshop skill-workshop/skill-workshop-review-*.json
• Nostr bus-state-*.json
• Nostr profile-state-*.json
• calls.jsonl
• known-users.json
• ref-index.jsonl
• QQBot session-*.json
• BlueBubbles bluebubbles/catchup/*.json
• BlueBubbles bluebubbles/inbound-dedupe/*.json
• Telegram update-offset-*.json
• Telegram sticker-cache.json
• Telegram *.telegram-messages.json
• Telegram *.telegram-sent-messages.json
• Telegram *.telegram-topic-names.json
• Telegram thread-bindings-*.json
• iMessage catchup/*.json
• iMessage reply-cache.jsonl
• iMessage sent-echoes.jsonl
• Microsoft Teams msteams-conversations.json
• Microsoft Teams msteams-polls.json
• Microsoft Teams msteams-sso-tokens.json
• Microsoft Teams *.learnings.json
• Matrix bot-storage.json
• Matrix sync-store.json
• Matrix thread-bindings.json
• Matrix inbound-dedupe.json
• Matrix startup-verification.json
• Matrix storage-meta.json
• Matrix crypto-idb-snapshot.json
• Discord model-picker-preferences.json
• Discord command-deploy-cache.json
• ไฟล์ JSON ของชาร์ดรีจิสทรีแซนด์บ็อกซ์
• plugin-state/state.sqlite
• ไฟล์ประกอบรันไทม์ openclaw-state.sqlite แบบเฉพาะกิจ
• tasks/runs.sqlite
• tasks/flows/registry.sqlite
• bindings/current-conversations.json
• restart-sentinel.json
• gateway-restart-intent.json
• gateway-supervisor-restart-handoff.json
• gateway.<hash>.lock
• qmd/embed.lock.lock
• agents/<agentId>/qmd-write.lock.lock
• commands.log
• config-health.json
• port-guard.json
• settings/voicewake.json
• settings/voicewake-routing.json
• plugin-binding-approvals.json
• plugins/installs.json
• audit/file-transfer.jsonl
• audit/crestodian.jsonl
• crestodian/rescue-pending/*.json
• openclaw/rescue-pending/*.json
• plugins/phone-control/armed.json
• Memory Wiki .openclaw-wiki/log.jsonl
• Memory Wiki .openclaw-wiki/state.json
• Memory Wiki .openclaw-wiki/locks/
• Memory Wiki .openclaw-wiki/source-sync.json
• Memory Wiki .openclaw-wiki/import-runs/*.json
• Memory Wiki .openclaw-wiki/cache/agent-digest.json
• Memory Wiki .openclaw-wiki/cache/claims.jsonl
• ClawHub .clawhub/lock.json
• ClawHub .clawhub/origin.json
• การตกแต่งโปรไฟล์เบราว์เซอร์ .openclaw-profile-decorated
• SessionManager.open(...) ตัวเปิดเซสชันที่ใช้ไฟล์เป็นแหล่งจัดเก็บ
• SessionManager.listAll(...) และ TranscriptSessionManager.listAll(...) ฟาซาดสำหรับแสดงรายการบทถอดเสียง
• SessionManager.forkFromSession(...) และ TranscriptSessionManager.forkFromSession(...) ฟาซาดสำหรับแยกแขนงบทถอดเสียง
• SessionManager.newSession(...) และ TranscriptSessionManager.newSession(...) ฟาซาดสำหรับแทนที่เซสชันแบบแก้ไขได้
• SessionManager.createBranchedSession(...) และ TranscriptSessionManager.createBranchedSession(...) ฟาซาดสำหรับเซสชันแขนง

ข้อห้ามควรอนุญาตให้การทดสอบสร้างฟิกซ์เจอร์แบบเดิม และอนุญาตให้โค้ดการย้ายข้อมูล อ่าน/นำเข้า/ลบแหล่งไฟล์แบบเดิมได้ ส่วนไฟล์ประกอบ SQLite ที่ยังไม่เคยเผยแพร่ยังคงถูกห้าม และไม่ได้รับข้อยกเว้นให้ Doctor นำเข้า

เกณฑ์การเสร็จสมบูรณ์

• การเขียนข้อมูลรันไทม์และแคชส่งไปยังฐานข้อมูล SQLite ส่วนกลางหรือของเอเจนต์
• รันไทม์ไม่เขียนดัชนีเซสชัน, JSONL ของบทถอดเสียง, JSON ของรีจิสทรี แซนด์บ็อกซ์, SQLite ไฟล์ประกอบของงาน หรือ SQLite ไฟล์ประกอบของสถานะ Plugin อีกต่อไป ตัวนำเข้า SQLite ไฟล์ประกอบ ของงานและสถานะ Plugin ที่ยังไม่เคยเผยแพร่จะถูกลบ
• การนำเข้าไฟล์แบบเดิมทำได้ผ่าน Doctor เท่านั้น
• การสำรองข้อมูลสร้างไฟล์เก็บถาวรหนึ่งไฟล์ที่มีสแนปช็อต SQLite แบบกระชับและหลักฐานยืนยันความสมบูรณ์
• เวิร์กเกอร์เอเจนต์สามารถทำงานโดยใช้ดิสก์, พื้นที่ชั่วคราว VFS หรือพื้นที่จัดเก็บ แบบทดลองที่ใช้ VFS เท่านั้น
• ไฟล์การกำหนดค่าและไฟล์ข้อมูลรับรองที่ระบุอย่างชัดเจนยังคงเป็นไฟล์ควบคุมถาวร ที่ไม่ใช่ฐานข้อมูลเพียงประเภทเดียวที่คาดว่าจะมี
• การตรวจสอบรีโปป้องกันไม่ให้นำที่เก็บไฟล์รันไทม์แบบเดิมกลับมาอีก