minicode-ai 0.11.0 → 0.13.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (221) hide show
  1. package/CHANGELOG.md +98 -0
  2. package/LICENSE +21 -21
  3. package/README.md +4 -4
  4. package/cli/args.ts +46 -0
  5. package/cli/commands/acp.ts +163 -10
  6. package/cli/commands/config.ts +33 -18
  7. package/cli/commands/daemon.ts +515 -0
  8. package/cli/commands/exec.ts +145 -53
  9. package/cli/commands/openwork.ts +986 -0
  10. package/cli/commands/sessions.ts +4 -1
  11. package/cli/commands/stats.ts +34 -4
  12. package/cli/commands.ts +217 -2
  13. package/cli/index.ts +146 -14
  14. package/cli/recovery-warning.ts +115 -0
  15. package/cli/router.ts +32 -1
  16. package/cli/setup.ts +2332 -171
  17. package/cli/tui.ts +113 -7
  18. package/docs/OUTPUT_ARCHITECTURE_AUDIT.md +489 -0
  19. package/docs/OUTPUT_EVENT_MODEL.md +289 -0
  20. package/docs/OUTPUT_IMPLEMENTATION_PLAN.md +391 -0
  21. package/docs/OUTPUT_PROTOCOL_SPEC.md +285 -0
  22. package/docs/OUTPUT_RENDERING_SPEC.md +248 -0
  23. package/docs/OUTPUT_UX_RULES.md +449 -0
  24. package/docs/PLAN_UIUX_V6.md +2 -2
  25. package/docs/README.md +4 -3
  26. package/docs/TERMINAL_CONTRACT.md +278 -66
  27. package/docs/architecture.md +89 -7
  28. package/docs/changelog.md +1 -1
  29. package/docs/choosing-mode.md +2 -2
  30. package/docs/cli.md +9 -5
  31. package/docs/concepts.md +1 -1
  32. package/docs/contributing.md +9 -2
  33. package/docs/environment.md +6 -2
  34. package/docs/exec.md +46 -5
  35. package/docs/memory-sessions.md +2 -0
  36. package/docs/policy-sandbox.md +1 -1
  37. package/docs/pricing-budget.md +1 -1
  38. package/docs/quickstart.md +2 -2
  39. package/docs/repl.md +6 -2
  40. package/docs/security-model.md +1 -1
  41. package/docs/security.md +1 -1
  42. package/docs/skills.md +2 -2
  43. package/docs/terminal.md +9 -5
  44. package/docs/tools.md +1 -1
  45. package/package.json +35 -5
  46. package/src/app/session.ts +261 -15
  47. package/src/app/tool-layer.ts +94 -7
  48. package/src/daemon/approvals.ts +361 -0
  49. package/src/daemon/capability.ts +145 -0
  50. package/src/daemon/children.ts +142 -0
  51. package/src/daemon/client.ts +267 -0
  52. package/src/daemon/control.ts +350 -0
  53. package/src/daemon/discovery.ts +234 -0
  54. package/src/daemon/feed.ts +155 -0
  55. package/src/daemon/framing.ts +94 -0
  56. package/src/daemon/host.ts +316 -0
  57. package/src/daemon/protocol.ts +217 -0
  58. package/src/daemon/resource.ts +170 -0
  59. package/src/daemon/sanitize.ts +57 -0
  60. package/src/daemon/server.ts +627 -0
  61. package/src/daemon/store.ts +317 -0
  62. package/src/daemon/subscription.ts +270 -0
  63. package/src/daemon/telemetry.ts +81 -0
  64. package/src/hooks/run.ts +12 -1
  65. package/src/lib/atomic-write.ts +29 -3
  66. package/src/lib/db-path.ts +26 -0
  67. package/src/lib/keystore.ts +544 -42
  68. package/src/lib/net.ts +43 -1
  69. package/src/lib/safe-open.ts +116 -1
  70. package/src/lib/session-id.ts +15 -0
  71. package/src/lsp/client.ts +123 -5
  72. package/src/mcp/client.ts +139 -17
  73. package/src/mcp/server.ts +177 -50
  74. package/src/mcp/transport.ts +16 -19
  75. package/src/memory/vector.ts +770 -55
  76. package/src/policy/allowlist.ts +14 -2
  77. package/src/policy/bash-guard.ts +105 -10
  78. package/src/policy/compaction.ts +82 -5
  79. package/src/policy/consequence-engine.ts +220 -0
  80. package/src/policy/context.ts +132 -0
  81. package/src/policy/executor.ts +187 -121
  82. package/src/policy/no-progress.ts +559 -0
  83. package/src/policy/permission.ts +4 -8
  84. package/src/policy/pricing.ts +17 -3
  85. package/src/policy/scrub.ts +69 -2
  86. package/src/policy/tool-contract.ts +515 -0
  87. package/src/policy/usage.ts +310 -24
  88. package/src/policy/verifier.ts +6 -3
  89. package/src/policy/work-mode.ts +182 -0
  90. package/src/presentation/adapter.ts +533 -26
  91. package/src/presentation/events.ts +151 -0
  92. package/src/presentation/model.ts +180 -27
  93. package/src/presentation/projection.ts +858 -0
  94. package/src/presentation/reducer.ts +645 -310
  95. package/src/presentation/store.ts +12 -7
  96. package/src/providers/anthropic.ts +18 -10
  97. package/src/providers/responses.ts +17 -7
  98. package/src/runtime/capability.ts +409 -0
  99. package/src/runtime/child-execution.ts +274 -0
  100. package/src/runtime/composition.ts +958 -0
  101. package/src/runtime/dispatch.ts +591 -0
  102. package/src/runtime/execution-backend.ts +632 -0
  103. package/src/runtime/execution-events.ts +272 -0
  104. package/src/runtime/execution-id.ts +230 -0
  105. package/src/runtime/execution-journal.ts +926 -0
  106. package/src/runtime/execution-kernel.ts +456 -0
  107. package/src/runtime/execution-registry.ts +379 -0
  108. package/src/runtime/process-supervision.ts +276 -0
  109. package/src/runtime/production-execution.ts +551 -0
  110. package/src/runtime/production-runtime.ts +217 -0
  111. package/src/runtime/recovery-safety.ts +70 -0
  112. package/src/runtime/recovery.ts +477 -0
  113. package/src/runtime/runtime-capabilities.ts +179 -0
  114. package/src/runtime/runtime-diagnostics.ts +141 -0
  115. package/src/runtime/runtime-host.ts +365 -0
  116. package/src/runtime/runtime-status-facts.ts +222 -0
  117. package/src/runtime/runtime-status-provider.ts +74 -0
  118. package/src/runtime/runtime-status.ts +459 -0
  119. package/src/runtime/runtime-task-admission.ts +101 -0
  120. package/src/runtime/supervisor.ts +444 -0
  121. package/src/session/authority.ts +168 -0
  122. package/src/session/checkpoint.ts +88 -1
  123. package/src/session/context-adapter.ts +251 -0
  124. package/src/session/context-assembly.ts +242 -0
  125. package/src/session/context-identity.ts +389 -0
  126. package/src/session/context-projection.ts +248 -0
  127. package/src/session/context-selector.ts +500 -0
  128. package/src/session/cross-session-adoption.ts +249 -0
  129. package/src/session/full-history-fold.ts +171 -0
  130. package/src/session/identity.ts +192 -0
  131. package/src/session/journal.ts +805 -102
  132. package/src/session/open-work-intent.ts +732 -0
  133. package/src/session/open-work.ts +767 -0
  134. package/src/session/pending-tools.ts +94 -0
  135. package/src/session/persistence.ts +3569 -127
  136. package/src/session/runtime-header.ts +208 -0
  137. package/src/session/shadow-git.ts +13 -5
  138. package/src/session/verification.ts +1623 -0
  139. package/src/task/assignment.ts +136 -0
  140. package/src/task/autonomous-adapter.ts +168 -0
  141. package/src/task/autonomous-context.ts +630 -0
  142. package/src/task/autonomous-policy.ts +490 -0
  143. package/src/task/continuity.ts +179 -0
  144. package/src/task/execution-cancellation.ts +165 -0
  145. package/src/task/graph-validate.ts +379 -0
  146. package/src/task/graph.ts +305 -0
  147. package/src/task/identity.ts +230 -0
  148. package/src/task/model.ts +417 -0
  149. package/src/task/production-scheduler.ts +293 -0
  150. package/src/task/readiness.ts +229 -0
  151. package/src/task/scheduler-observability.ts +387 -0
  152. package/src/task/scheduler.ts +1197 -0
  153. package/src/task/scheduling-policy.ts +165 -0
  154. package/src/task/session-authority.ts +148 -0
  155. package/src/task/session-ownership.ts +211 -0
  156. package/src/task/store.ts +2887 -0
  157. package/src/task/sync.ts +343 -0
  158. package/src/task/trigger.ts +260 -0
  159. package/src/tools/bash.ts +377 -211
  160. package/src/tools/code_run.ts +1 -1
  161. package/src/tools/delete_file.ts +1 -1
  162. package/src/tools/edit.ts +33 -6
  163. package/src/tools/evidence.ts +30 -0
  164. package/src/tools/git.ts +4 -4
  165. package/src/tools/glob.ts +12 -3
  166. package/src/tools/grep.ts +1 -1
  167. package/src/tools/lsp.ts +4 -4
  168. package/src/tools/mcp_call.ts +11 -4
  169. package/src/tools/memory.ts +153 -18
  170. package/src/tools/move_file.ts +1 -1
  171. package/src/tools/patch.ts +1 -1
  172. package/src/tools/read_file.ts +1 -1
  173. package/src/tools/read_image.ts +1 -1
  174. package/src/tools/submit_result.ts +1 -1
  175. package/src/tools/task.ts +437 -41
  176. package/src/tools/todo.ts +662 -35
  177. package/src/tools/web_fetch.ts +4 -2
  178. package/src/tools/web_search.ts +9 -3
  179. package/src/tools/write_file.ts +1 -1
  180. package/src/ui/assistant/simple.ts +123 -50
  181. package/src/ui/assistant/turn-status.ts +17 -3
  182. package/src/ui/contract.ts +184 -0
  183. package/src/ui/footer.ts +54 -18
  184. package/src/ui/i18n/en.ts +62 -6
  185. package/src/ui/i18n/id.ts +62 -6
  186. package/src/ui/input/prompt-engine.ts +120 -25
  187. package/src/ui/render/errors.ts +39 -1
  188. package/src/ui/render/markdown-table.ts +455 -0
  189. package/src/ui/render/markdown.ts +22 -1
  190. package/src/ui/render/table-grid.ts +184 -0
  191. package/src/ui/render/table.ts +15 -76
  192. package/src/ui/runtime/screen.ts +7 -2
  193. package/src/ui/runtime/statusline.ts +25 -6
  194. package/src/ui/tui/app.ts +598 -133
  195. package/src/ui/tui/transcript.ts +531 -89
  196. package/vendor/minicore/VENDOR.md +1 -1
  197. package/vendor/minicore/src/core/budget.ts +25 -25
  198. package/vendor/minicore/src/core/compact.ts +75 -75
  199. package/vendor/minicore/src/core/errors.ts +59 -59
  200. package/vendor/minicore/src/core/events.ts +73 -73
  201. package/vendor/minicore/src/core/executor.ts +139 -139
  202. package/vendor/minicore/src/core/history.ts +31 -31
  203. package/vendor/minicore/src/core/index.ts +41 -41
  204. package/vendor/minicore/src/core/loop.ts +355 -355
  205. package/vendor/minicore/src/core/permission.ts +22 -22
  206. package/vendor/minicore/src/core/provider.ts +39 -39
  207. package/vendor/minicore/src/core/recovery.ts +35 -35
  208. package/vendor/minicore/src/core/session.ts +327 -327
  209. package/vendor/minicore/src/core/snapshot.ts +146 -146
  210. package/vendor/minicore/src/core/tokens.ts +107 -107
  211. package/vendor/minicore/src/core/tool.ts +115 -115
  212. package/vendor/minicore/src/core/types.ts +50 -50
  213. package/vendor/minicore/src/providers/openai-compat.ts +417 -417
  214. package/AGENTS.md +0 -45
  215. package/PLAN.md +0 -491
  216. package/docs/ARCHITECTURE.html +0 -1248
  217. package/docs/CONTROL-PLANE-MAP.md +0 -139
  218. package/docs/HARNESS.md +0 -150
  219. package/docs/SUMMARY.md +0 -52
  220. package/docs/UI_RENDER_PIPELINE.md +0 -165
  221. package/docs/USAGE.md +0 -11
@@ -1,78 +1,564 @@
1
1
  import { Database } from "bun:sqlite"
2
+ import { createHash, randomUUID } from "node:crypto"
3
+ import { existsSync } from "node:fs"
2
4
  import { LIMITS } from "../constants.ts"
3
- import { resolveDbPath } from "../lib/db-path.ts"
5
+ import { resolveDbPath, resolveLocalDbPath } from "../lib/db-path.ts"
6
+ import { scrubSecrets } from "../policy/scrub.ts"
7
+ import { type DomainEvent, DURABILITY } from "../presentation/events.ts"
4
8
 
5
- const dbPath = (cwd?: string) => resolveDbPath("sessions.db", cwd)
9
+ // `local=true` = SELALU `<cwd>/.minicode/sessions.db`, tanpa fallback ke
10
+ // `~/.minicode` global. Fallback global itu benar untuk histori lintas-repo,
11
+ // tetapi salah untuk state per-workspace (offset konsumen & persetujuan
12
+ // daemon): proyek A yang "melanjutkan" dari progres proyek B adalah bocoran
13
+ // scope yang tak pernah bisa dilihat pemakai.
14
+ const dbPath = (cwd?: string, local = false) =>
15
+ local ? resolveLocalDbPath("sessions.db", cwd) : resolveDbPath("sessions.db", cwd)
6
16
 
7
17
  const initializedSessionPaths = new Set<string>()
8
18
 
9
- function open(cwd?: string): Database {
10
- const p = dbPath(cwd)
11
- const db = new Database(p)
12
- // busy_timeout DULU, sebelum statement apa pun yang butuh lock (audit #09
13
- // P1 §27: dua proses membuka DB bersamaan → PRAGMA journal_mode balapan →
14
- // SQLITE_BUSY padahal timeout 3000ms belum aktif — reproducer: 2×
15
- // loadSession konkuren lintas proses, satu gagal). Set pragma tak butuh
16
- // lock data sehingga aman duluan.
19
+ // [Audit #2 C.F1] Gate DDL/migrasi per path. `initializedSessionPaths` hanya
20
+ // men-gate PRAGMA WAL; ~30 statement DDL (CREATE TABLE IF NOT EXISTS, PRAGMA
21
+ // table_info, ALTER TABLE) TIDAK di-gate di jalur lama, sehingga dijalankan
22
+ // ulang di setiap `open()` (50 call site). Set ini menandai path yang SKEMA-nya
23
+ // sudah jadi, asal marker migrasi terakhir (kolom daemon_approvals.invocation_id)
24
+ // masih ada di koneksi.
25
+ const migratedSessionPaths = new Set<string>()
26
+
27
+ /**
28
+ * [Audit #2 C.F1] Cek tanda migrasi SELESAI di koneksi saat ini (bukan cache
29
+ * lintas-handle). Marker = kolom `daemon_approvals.invocation_id` (kolom PALING
30
+ * AKHIR yang ditambahkan migrasi). Cek KOLOM — bukan sekadar keberadaan tabel —
31
+ * karena test migrasi menurunkan DB lama dengan DROP COLUMN: tabel `daemon_approvals`
32
+ * tetap ada tapi kolom pengikatnya hilang, dan harus di-ALTER ulang.
33
+ */
34
+ function daemonApprovalsMigrated(db: Database): boolean {
17
35
  try {
18
- db.exec(`PRAGMA busy_timeout=${LIMITS.SQLITE_BUSY_TIMEOUT_MS}`)
19
- } catch {}
20
- if (!initializedSessionPaths.has(p)) {
21
- // journal_size_limit + wal_autocheckpoint: WAL tidak tumbuh tak terbatas.
22
- // Bungkus try/catch DENGAN retry-next-open (audit 2026-09-16): di Windows,
23
- // lock AV/file sesaat saat dua proses membuka bersamaan membuat setup WAL
24
- // gagal SQLITE_IOERR_TRUNCATE — crash di sini mematikan SELURUH operasi
25
- // sesi padahal mode rollback-journal tetap bisa baca. Jangan tandai
26
- // initialized bila gagal agar open berikutnya mencoba lagi (mode WAL
27
- // persisten di berkas DB, jadi sekali sukses berlaku untuk semua handle).
36
+ const cols = db.prepare("PRAGMA table_info(daemon_approvals)").all() as { name: string }[]
37
+ return cols.some((c) => c.name === "invocation_id")
38
+ } catch {
39
+ return false
40
+ }
41
+ }
42
+
43
+ /**
44
+ * Retry sinkron untuk blok setup schema di `open()`.
45
+ *
46
+ * Ditemukan oleh test baseline Phase 0: `open()` menjalankan
47
+ * `CREATE TABLE IF NOT EXISTS` TANPA pagar retry, padahal `busy_timeout` sudah
48
+ * diset. Akibatnya satu penulis yang lock-nya ditahan membuat PEMBUKA DB
49
+ * melempar SQLITE_BUSY — dan itu terjadi SEBELUM `withBusyRetry` di
50
+ * `appendPresentationEvents` sempat dipanggil. Jadi jalur retry yang ada tidak
51
+ * pernah menyelamatkan operasi yang paling butuh: DB-nya sendiri belum siap.
52
+ *
53
+ * `withBusyRetry` (async) tidak bisa dipakai di sini karena `open()` sinkron
54
+ * dan dipanggil dari jalur sinkron (`loadSession`, `listSessions`, dst).
55
+ */
56
+ // Konstanta retry inisialisasi DB. Naikkan dari 3 (baseline) ke 8 dengan
57
+ // backoff exponential + jitter kecil agar tahan terhadap lonjakan proses
58
+ // paralel di Windows/POSIX (temuan Live #1: dua CLI paralel → SQLITE_BUSY
59
+ // saat `new Database(p)` + PRAGMA setup, salah satu proses gagal di
60
+ // `cli/router.ts`). Backoff: 15+0, 30+j, 60+j, 120+j, 240+j, 480+j, 960+j,
61
+ // 1920+j ms → total ≤ ~3,8 dtk untuk 8 percobaan, masih di bawah budget
62
+ // startup. Jitter memecah sinkronisasi antar-proses yang mencoba ulang
63
+ // pada waktu yang sama (thundering herd).
64
+ const DB_INIT_ATTEMPTS = 8
65
+ const DB_INIT_BACKOFF_MS = 15
66
+
67
+ function dbInitBackoffMs(attempt: number): number {
68
+ const base = DB_INIT_BACKOFF_MS * 2 ** attempt
69
+ // jitter deterministik kecil (±20%) dari attempt ke-2 dst; attempt pertama
70
+ // (i=0) tidak dijitter agar kasus SQLITE_BUSY tunggal tetap selesai secepat
71
+ // mungkin (tanpa menambah latensi startup untuk jalur yang TIDAK balapan).
72
+ if (attempt === 0) return base
73
+ return base + ((attempt * 7919 + 3) % Math.max(1, Math.floor(base * 0.2)))
74
+ }
75
+
76
+ // [Phase 12.2] Predikat kontensi SQLite transien lintas-proses (buka/WAL di
77
+ // Windows). Sebelumnya hanya SQLITE_BUSY/"database is locked" yang di-retry; di
78
+ // Windows, dua proses yang membuka WAL bersamaan di bawah beban disk tinggi juga
79
+ // melempar SQLITE_IOERR_TRUNCATE / SQLITE_IOERR_SHMOPEN / SQLITE_IOERR_LOCK /
80
+ // SQLITE_PROTOCOL / SQLITE_LOCKED — semuanya transien (kompetisi lock), bukan
81
+ // korupsi, dan AMAN di-retry. Bun menaruh kode simbolik di `error.code` dan teks
82
+ // manusiawi di `error.message` (mis. SQLITE_BUSY = "database is locked",
83
+ // SQLITE_IOERR_* = "disk I/O error" atau kode extended), jadi keduanya diperiksa.
84
+ // SENGAJA TIDAK di-retry: SQLITE_CORRUPT / SQLITE_NOTADB / constraint error — retry
85
+ // buta hanya menyembunyikan korupsi skema/data yang nyata.
86
+ const SQLITE_CONTENTION_RE =
87
+ /SQLITE_BUSY|database is locked|database table is locked|SQLITE_LOCKED|SQLITE_PROTOCOL|SQLITE_IOERR_TRUNCATE|SQLITE_IOERR_SHMOPEN|SQLITE_IOERR_LOCK|disk I\/O error/i
88
+
89
+ function isSqliteContention(e: unknown): boolean {
90
+ const code = (e as { code?: unknown } | null)?.code
91
+ if (typeof code === "string" && SQLITE_CONTENTION_RE.test(code)) return true
92
+ const msg = e instanceof Error ? String(e.message ?? e) : String(e)
93
+ return SQLITE_CONTENTION_RE.test(msg)
94
+ }
95
+
96
+ export function withBusyRetrySync<T>(fn: () => T, attempts = DB_INIT_ATTEMPTS): T | null {
97
+ let last: unknown
98
+ for (let i = 0; i < attempts; i++) {
28
99
  try {
29
- db.exec(
30
- `PRAGMA journal_mode=WAL; PRAGMA busy_timeout=${LIMITS.SQLITE_BUSY_TIMEOUT_MS}; PRAGMA synchronous=NORMAL; PRAGMA journal_size_limit=${LIMITS.SQLITE_WAL_SIZE_LIMIT_BYTES}; PRAGMA wal_autocheckpoint=${LIMITS.SQLITE_WAL_AUTOCHECKPOINT_PAGES};`,
31
- )
32
- initializedSessionPaths.add(p)
100
+ return fn()
33
101
  } catch (e) {
34
- process.stderr.write(
35
- `[warn] persistence: wal setup deferred, retry next open: ${(e as Error).message}\n`,
36
- )
102
+ // [Phase 12.2] Retry hanya pada kontensi SQLite transien (lihat
103
+ // isSqliteContention); korupsi (SQLITE_CORRUPT/NOTADB), constraint, dan
104
+ // error non-kontensi lain dilempar segera.
105
+ if (!isSqliteContention(e)) throw e
106
+ last = e
107
+ // Backoff sinkron eksponensial + jitter kecil (lihat dbInitBackoffMs).
108
+ Bun.sleepSync(dbInitBackoffMs(i))
37
109
  }
38
- // File DB dibuat dengan 644 default; ubah ke 600 agar history tidak world-readable
110
+ }
111
+ process.stderr.write(
112
+ `[warn] persistence: schema setup gave up after ${attempts} attempts: ${String((last as Error)?.message ?? last)}\n`,
113
+ )
114
+ return null
115
+ }
116
+
117
+ function open(cwd?: string, local = false): Database {
118
+ const p = dbPath(cwd, local)
119
+ // [Phase 7 / Live #1] Pembukaan koneksi + PRAGMA setup dibungkus dengan
120
+ // withBusyRetrySync. Sebelumnya hanya DDL yang di-retry; `new Database(p)`
121
+ // dan `PRAGMA journal_mode=WAL` bisa gagal SQLITE_BUSY saat dua proses CLI
122
+ // paralel membuka DB bersamaan (race nyata di cli/router.ts:128). Dengan
123
+ // membungkus seluruh urutan inisialisasi, proses yang kalah tunggu lalu
124
+ // coba ulang sampai lock dilepas (backoff eksponensial + jitter, 8×).
125
+ // PRAGMA busy_timeout DIATUR dalam retry yang sama SEBELUM journal_mode:
126
+ // peralihan ke WAL butuh exclusive lock sesaat yang langsung gagal tanpa
127
+ // busy_timeout aktif (audit #09 P1 §27).
128
+ const db = withBusyRetrySync(() => {
129
+ const d = new Database(p)
39
130
  try {
40
- const { chmodSync } = require("node:fs") as typeof import("node:fs")
41
- chmodSync(p, 0o600)
42
- // WAL/SHM akan dibuat dengan mode yang sama pada checkpoint berikutnya
131
+ d.exec(`PRAGMA busy_timeout=${LIMITS.SQLITE_BUSY_TIMEOUT_MS}`)
43
132
  } catch {}
133
+ return d
134
+ })
135
+ if (!db) {
136
+ throw new Error(
137
+ `persistence: cannot open sessions.db after ${DB_INIT_ATTEMPTS} busy-retry attempts: ${p}`,
138
+ )
44
139
  }
45
- db.exec(`
46
- CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, created_at INTEGER, cwd TEXT, system TEXT);
47
- CREATE TABLE IF NOT EXISTS messages (session_id TEXT, seq INTEGER, role TEXT, content TEXT, toolCalls TEXT, toolCallId TEXT, name TEXT, ts INTEGER, PRIMARY KEY(session_id, seq));
140
+ // [Audit #3 RL-1] Seluruh langkah pasca-konstruksi (WAL + DDL/migrasi) dibungkus
141
+ // agar kegagalan SQLITE_IOERR/CORRUPT menutup handle `Database` — bukan bocor.
142
+ try {
143
+ if (!initializedSessionPaths.has(p)) {
144
+ // journal_size_limit + wal_autocheckpoint: WAL tidak tumbuh tak terbatas.
145
+ // Bungkus try/catch DENGAN retry-next-open (audit 2026-09-16): di Windows,
146
+ // lock AV/file sesaat saat dua proses membuka bersamaan membuat setup WAL
147
+ // gagal SQLITE_IOERR_TRUNCATE — crash di sini mematikan SELURUH operasi
148
+ // sesi padahal mode rollback-journal tetap bisa baca. Jangan tandai
149
+ // initialized bila gagal agar open berikutnya mencoba lagi (mode WAL
150
+ // persisten di berkas DB, jadi sekali sukses berlaku untuk semua handle).
151
+ // Phase 7: PRAGMA setup ini juga dibungkus withBusyRetrySync karena
152
+ // peralihan WAL butuh exclusive lock sesaat.
153
+ const walOk = withBusyRetrySync(() => {
154
+ db.exec(
155
+ `PRAGMA journal_mode=WAL; PRAGMA busy_timeout=${LIMITS.SQLITE_BUSY_TIMEOUT_MS}; PRAGMA synchronous=NORMAL; PRAGMA journal_size_limit=${LIMITS.SQLITE_WAL_SIZE_LIMIT_BYTES}; PRAGMA wal_autocheckpoint=${LIMITS.SQLITE_WAL_AUTOCHECKPOINT_PAGES};`,
156
+ )
157
+ initializedSessionPaths.add(p)
158
+ return true
159
+ })
160
+ if (walOk === null) {
161
+ process.stderr.write(`[warn] persistence: wal setup deferred, retry next open: ${p}\n`)
162
+ }
163
+ // File DB dibuat dengan 644 default; ubah ke 600 agar history tidak world-readable
164
+ try {
165
+ const { chmodSync } = require("node:fs") as typeof import("node:fs")
166
+ chmodSync(p, 0o600)
167
+ // WAL/SHM akan dibuat dengan mode yang sama pada checkpoint berikutnya
168
+ } catch {}
169
+ }
170
+ // [Audit #2 C.F1] DDL/migrasi DI-GATE per path: bila path sudah di-migrasi
171
+ // DAN marker migrasi terakhir (kolom daemon_approvals.invocation_id) masih ada
172
+ // di koneksi ini, lewati seluruh blok CREATE/ALTER. Cek KOLOM di koneksi saat
173
+ // ini memastikan DB yang dihapus + dibuat ulang (atau kolom di-DROP oleh test
174
+ // migrasi) TETAP di-migrasi ulang — Set hanya cache path, bukan handle Database.
175
+ const needsDdl = !migratedSessionPaths.has(p) || !daemonApprovalsMigrated(db)
176
+ if (needsDdl) {
177
+ // DDL setup: `CREATE TABLE IF NOT EXISTS` butuh lock tulis bila tabel belum
178
+ // ada. Tanpa retry di sini, DB yang sedang dikunci proses lain membuat
179
+ // SETIAP operasi sesi gagal seketika. `null` = gagal terus; pemanggil akan
180
+ // gagal di statement berikutnya dengan pesan yang lebih jelas.
181
+ withBusyRetrySync(() => {
182
+ db.exec(`
183
+ CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, created_at INTEGER, cwd TEXT, system TEXT, writer_epoch INTEGER NOT NULL DEFAULT 0, default_thread_id TEXT NULL);
184
+ CREATE TABLE IF NOT EXISTS messages (session_id TEXT, seq INTEGER, role TEXT, content TEXT, toolCalls TEXT, toolCallId TEXT, name TEXT, reasoning TEXT, is_error INTEGER, ts INTEGER, thread_id TEXT NULL, event_id TEXT NULL, run_id TEXT NULL, migrated INTEGER NOT NULL DEFAULT 0, migrated_compacted INTEGER NOT NULL DEFAULT 0, projection_note TEXT NULL, PRIMARY KEY(session_id, seq));
48
185
  CREATE TABLE IF NOT EXISTS turns (session_id TEXT, turn_idx INTEGER, usage TEXT, ts INTEGER, PRIMARY KEY(session_id, turn_idx));
186
+ CREATE TABLE IF NOT EXISTS presentation_events (
187
+ session_id TEXT NOT NULL,
188
+ event_seq INTEGER NOT NULL,
189
+ type TEXT NOT NULL,
190
+ turn_id INTEGER NOT NULL,
191
+ ts INTEGER NOT NULL,
192
+ payload TEXT NOT NULL,
193
+ PRIMARY KEY(session_id, event_seq)
194
+ );
49
195
  CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id, seq);
196
+ CREATE INDEX IF NOT EXISTS idx_presentation_events_session ON presentation_events(session_id, event_seq);
50
197
  `)
51
- // migration: add updated_at, toolCallId, name jika kolom lama (backward-compat)
52
- try {
53
- const cols = db.prepare("PRAGMA table_info(sessions)").all() as { name: string }[]
54
- if (!cols.some((c) => c.name === "updated_at")) {
55
- db.exec("ALTER TABLE sessions ADD COLUMN updated_at INTEGER")
56
- db.exec("UPDATE sessions SET updated_at = created_at WHERE updated_at IS NULL")
198
+ })
199
+ // migration: add updated_at, toolCallId, name jika kolom lama (backward-compat)
200
+ try {
201
+ const cols = db.prepare("PRAGMA table_info(sessions)").all() as { name: string }[]
202
+ if (!cols.some((c) => c.name === "updated_at")) {
203
+ db.exec("ALTER TABLE sessions ADD COLUMN updated_at INTEGER")
204
+ db.exec("UPDATE sessions SET updated_at = created_at WHERE updated_at IS NULL")
205
+ }
206
+ db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC)`)
207
+ // P2.9 — lineage Sub-Agent. Aditif + idempoten. NULL = sesi root (parent
208
+ // ATAU anak legasi pra-P2.9). Sesi anak MEILIKI baris sessions sendiri;
209
+ // ini yang menutup cacat namespace hantu (presentation_events.session_id
210
+ // menunjuk id tanpa baris sessions → dihapus orphan-purge).
211
+ if (!cols.some((c) => c.name === "parent_session_id")) {
212
+ db.exec("ALTER TABLE sessions ADD COLUMN parent_session_id TEXT NULL")
213
+ }
214
+ if (!cols.some((c) => c.name === "parent_run_id")) {
215
+ db.exec("ALTER TABLE sessions ADD COLUMN parent_run_id TEXT NULL")
216
+ }
217
+ db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_parent ON sessions(parent_session_id)`)
218
+ } catch (e) {
219
+ process.stderr.write(
220
+ `[warn] persistence: sessions migration skipped: ${(e as Error).message}\n`,
221
+ )
222
+ }
223
+ try {
224
+ const msgCols = db.prepare("PRAGMA table_info(messages)").all() as { name: string }[]
225
+ if (!msgCols.some((c) => c.name === "toolCallId")) {
226
+ db.exec("ALTER TABLE messages ADD COLUMN toolCallId TEXT")
227
+ db.exec("ALTER TABLE messages ADD COLUMN name TEXT")
228
+ }
229
+ // Fidelity resume: `reasoning` (thinking DeepSeek-style) dan `is_error`
230
+ // (tool gagal) adalah bagian dari kernel Message dan ikut dibawa ke
231
+ // history, tapi kolomnya tak pernah ada — resume lama sewajarnya buta dan
232
+ // model kehilangan konteks kegagalannya. Additive, jadi DB lama tetap
233
+ // terbaca dan turn lama (tanpa kolom ini) tetap resume dengan isError
234
+ // diperlakukan absen.
235
+ if (!msgCols.some((c) => c.name === "reasoning")) {
236
+ db.exec("ALTER TABLE messages ADD COLUMN reasoning TEXT")
237
+ }
238
+ if (!msgCols.some((c) => c.name === "is_error")) {
239
+ db.exec("ALTER TABLE messages ADD COLUMN is_error INTEGER")
240
+ }
241
+ } catch (e) {
242
+ process.stderr.write(
243
+ `[warn] persistence: messages migration skipped: ${(e as Error).message}\n`,
244
+ )
245
+ }
246
+ // P2.1 — peta alias identitas sesi: alias (input mentah eksak) → kanonik.
247
+ // Additive: DB lama mendapat tabel kosong; tak ada baris lama yang berubah.
248
+ // `alias` = input mentah persis (bukan hasil sanitasi) agar tabrakan
249
+ // sanitizer (`a/b` vs `a-b`) tetap terbedakan; `fs_key` = bentuk kanonik
250
+ // untuk deteksi tabrakan kunci filesystem.
251
+ withBusyRetrySync(() => {
252
+ db.exec(`
253
+ CREATE TABLE IF NOT EXISTS session_aliases (alias TEXT PRIMARY KEY, fs_key TEXT NOT NULL, canonical TEXT NOT NULL, reason TEXT NOT NULL, created_at INTEGER NOT NULL);
254
+ CREATE INDEX IF NOT EXISTS idx_session_aliases_fs ON session_aliases(fs_key);
255
+ CREATE INDEX IF NOT EXISTS idx_session_aliases_canonical ON session_aliases(canonical);
256
+ `)
257
+ })
258
+ // P2.2 — pagar penulis (writer fence): generasi otoritas penulis dalam
259
+ // satu generasi identitas sesi. BEDA dari inkarnasi TaskStore (generasi
260
+ // identitas lintas delete/recreate): epoch hanya maju lewat takeover dan
261
+ // tak pernah diubah save biasa. Baris lama → 0 (deterministik).
262
+ // P2.3 — slot default_thread_id (nullable transisional; P2.4 menegakkan
263
+ // invariant) + kolom dorman messages (NULL/0 = legacy tak-berskala;
264
+ // P2.4 backfill, P2.5 alokator + UNIQUE event_id via index).
265
+ try {
266
+ const sessCols = db.prepare("PRAGMA table_info(sessions)").all() as { name: string }[]
267
+ if (!sessCols.some((c) => c.name === "writer_epoch")) {
268
+ db.exec("ALTER TABLE sessions ADD COLUMN writer_epoch INTEGER NOT NULL DEFAULT 0")
269
+ }
270
+ if (!sessCols.some((c) => c.name === "default_thread_id")) {
271
+ db.exec("ALTER TABLE sessions ADD COLUMN default_thread_id TEXT NULL")
272
+ }
273
+ const msgCols2 = db.prepare("PRAGMA table_info(messages)").all() as { name: string }[]
274
+ const addMsgCol = (name: string, ddl: string): void => {
275
+ if (!msgCols2.some((c) => c.name === name))
276
+ db.exec(`ALTER TABLE messages ADD COLUMN ${ddl}`)
277
+ }
278
+ addMsgCol("thread_id", "thread_id TEXT NULL")
279
+ addMsgCol("event_id", "event_id TEXT NULL")
280
+ addMsgCol("run_id", "run_id TEXT NULL")
281
+ addMsgCol("migrated", "migrated INTEGER NOT NULL DEFAULT 0")
282
+ addMsgCol("migrated_compacted", "migrated_compacted INTEGER NOT NULL DEFAULT 0")
283
+ addMsgCol("projection_note", "projection_note TEXT NULL")
284
+ // P2.6: takeover_epoch untuk runs (NULL = pra-P2.6; diisi saat create).
285
+ try {
286
+ const runCols = db.prepare("PRAGMA table_info(runs)").all() as { name: string }[]
287
+ if (runCols.length > 0 && !runCols.some((c) => c.name === "takeover_epoch")) {
288
+ db.exec("ALTER TABLE runs ADD COLUMN takeover_epoch INTEGER NULL")
289
+ }
290
+ } catch {
291
+ // Tabel absen (handle mentah) atau gagal — CREATE di atas yang berlaku.
292
+ }
293
+ // P2.7: anchor_event_id untuk history_projections (NULL = pra-P2.7 atau
294
+ // cakupan kosong; diisi saat build bila base_seq > 0). Aditif idempoten
295
+ // seperti kolom di atas; baris lama (bila ada) dipertahankan utuh.
296
+ try {
297
+ const projCols = db.prepare("PRAGMA table_info(history_projections)").all() as {
298
+ name: string
299
+ }[]
300
+ if (projCols.length > 0 && !projCols.some((c) => c.name === "anchor_event_id")) {
301
+ db.exec("ALTER TABLE history_projections ADD COLUMN anchor_event_id TEXT NULL")
302
+ }
303
+ } catch {
304
+ // Tabel absen atau gagal — CREATE di bawah yang berlaku.
305
+ }
306
+ // Indeks di SINI (setelah ALTER): CREATE INDEX atas kolom yang belum ada
307
+ // melempar di DB legacy bila dikerjakan sebelum migrasi kolom (temuan
308
+ // P2.3: open() gagal total). Idempoten seperti indeks lain di atas.
309
+ // P2.4 — identitas histori kanonik (session_id, thread_id, seq): UNIQUE
310
+ // (menggantikan idx_messages_thread P2.3 yang salah-bentuk tanpa
311
+ // session_id). NULL thread legacy dikecualikan SQLite secara alami.
312
+ // P2.5 — keunikan event: UNIQUE(session_id, thread_id, event_id).
313
+ // NULL dikecualikan (baris legacy pra-backfill tak pernah konflik);
314
+ // komposit (bukan global) agar branch PRESERVE event_id tetap konsisten
315
+ // (masa lalu bersama = id sama di sesi berbeda — analogi objek git).
316
+ db.exec("DROP INDEX IF EXISTS idx_messages_thread")
317
+ withBusyRetrySync(() => {
318
+ db.exec(`
319
+ CREATE UNIQUE INDEX IF NOT EXISTS udx_messages_thread_seq ON messages(session_id, thread_id, seq);
320
+ CREATE UNIQUE INDEX IF NOT EXISTS udx_messages_event_id ON messages(session_id, thread_id, event_id);
321
+ CREATE INDEX IF NOT EXISTS idx_messages_run ON messages(run_id);
322
+ `)
323
+ })
324
+ } catch (e) {
325
+ process.stderr.write(
326
+ `[warn] persistence: writer_epoch migration skipped: ${(e as Error).message}\n`,
327
+ )
328
+ }
329
+ // P2.2 — rekaman takeover durable: SATU baris per (sesi, prior_epoch).
330
+ // Keunikan inilah yang membuat takeover simultan punya tepat satu pemenang
331
+ // (tanpa mengandalkan Date.now): pecundang menabrak constraint dan
332
+ // mengamati hasil pemenang (idempoten), bukan menaikkan epoch lagi.
333
+ withBusyRetrySync(() => {
334
+ db.exec(`
335
+ CREATE TABLE IF NOT EXISTS session_takeovers (session_id TEXT NOT NULL, prior_epoch INTEGER NOT NULL, new_epoch INTEGER NOT NULL, reason TEXT NOT NULL, boot TEXT NOT NULL, created_at INTEGER NOT NULL, PRIMARY KEY(session_id, prior_epoch));
336
+ CREATE INDEX IF NOT EXISTS idx_session_takeovers_session ON session_takeovers(session_id);
337
+ `)
338
+ })
339
+ // P2.3 — kerangka penyimpanan (STORAGE ONLY, tanpa semantik aktif).
340
+ // Ketiga tabel + kolom dorman di bawah TIDAK ditulis/dibaca runtime mana
341
+ // pun di fase ini; P2.4 (Thread), P2.5 (Run/kursor), P2.7 (proyeksi) yang
342
+ // mengaktifkannya. Konvensi migrasi = DDL idempoten di open() (tanpa
343
+ // user_version: semua perubahan aditif; restart-safe via idempotence,
344
+ // bukan via atomisitas DDL — SQLite men-commit tiap statement).
345
+ // P2.4 — koreksi identitas Thread: komposit (session_id, thread_id).
346
+ // Skema P2.3 memakai thread_id PK global (satu 'th_default' sedunia —
347
+ // mustahil). Identitas kanonik menurut blueprint adalah pasangan
348
+ // (session, thread); runs/projections sudah membawa session_id. Rebuild
349
+ // HANYA bila bentuk lama terdeteksi (di bawah); AMAN karena tabel P2.3
350
+ // dijamin kosong (guard netralitas + assert menolak bila ada baris —
351
+ // tak pernah hapus data). Open berulang pada bentuk baru = no-op.
352
+ if (threadsTableNeedsP24Rebuild(db)) {
353
+ assertEmptyTableForRebuild(db, "threads")
354
+ db.exec("DROP TABLE IF EXISTS threads")
355
+ }
356
+ if (projectionsTableNeedsP24Rebuild(db)) {
357
+ assertEmptyTableForRebuild(db, "history_projections")
358
+ db.exec("DROP TABLE IF EXISTS history_projections")
359
+ }
360
+ withBusyRetrySync(() => {
361
+ db.exec(`
362
+ CREATE TABLE IF NOT EXISTS threads (session_id TEXT NOT NULL, thread_id TEXT NOT NULL, parent_thread_id TEXT NULL, fork_event_seq INTEGER NULL, head_seq INTEGER NOT NULL DEFAULT -1, status TEXT NOT NULL DEFAULT 'active', read_only INTEGER NOT NULL DEFAULT 0, created_at INTEGER NOT NULL, PRIMARY KEY(session_id, thread_id), CHECK(head_seq >= -1), CHECK(fork_event_seq IS NULL OR fork_event_seq >= 0));
363
+ CREATE INDEX IF NOT EXISTS idx_threads_session ON threads(session_id);
364
+ CREATE TABLE IF NOT EXISTS runs (run_id TEXT PRIMARY KEY, session_id TEXT NOT NULL, thread_id TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'CREATED', started_at INTEGER NOT NULL, ended_at INTEGER NULL, last_persisted_seq INTEGER NOT NULL DEFAULT 0, pending_tool_ids TEXT NOT NULL DEFAULT '[]', recovery_status TEXT NULL, takeover_epoch INTEGER NULL, created_at INTEGER NOT NULL, CHECK(last_persisted_seq >= 0));
365
+ CREATE INDEX IF NOT EXISTS idx_runs_session ON runs(session_id, started_at);
366
+ CREATE INDEX IF NOT EXISTS idx_runs_thread ON runs(thread_id, started_at);
367
+ -- P2.6: ≤1 RUNNING per SESSION (partial unique index = DB-enforced,
368
+ -- TOCTOU-safe; pelumba kedua gagal constraint, bukan tayang ganda).
369
+ CREATE UNIQUE INDEX IF NOT EXISTS udx_runs_single_running ON runs(session_id) WHERE status = 'RUNNING';
370
+ CREATE TABLE IF NOT EXISTS history_projections (session_id TEXT NOT NULL, thread_id TEXT NOT NULL, projection_id TEXT NOT NULL, base_seq INTEGER NOT NULL DEFAULT 0, summary_text TEXT NOT NULL DEFAULT '', included_ranges TEXT NOT NULL DEFAULT '[]', built_at INTEGER NOT NULL, anchor_event_id TEXT NULL, PRIMARY KEY(session_id, thread_id, projection_id), CHECK(base_seq >= 0));
371
+ CREATE INDEX IF NOT EXISTS idx_projections_thread ON history_projections(session_id, thread_id);
372
+ `)
373
+ })
374
+ // P2.12 — dua tabel milik daemon, DDL di sini karena `open()` SATU-SATUNYA
375
+ // pemilik skema (setiap jalur buka DB melewati retry yang sama; DDL terpisah
376
+ // di modul lain = dua jalur setup yang bisa berbeda urutan lock-nya).
377
+ //
378
+ // consumer_offsets: offset terakhir yang DIACK konsumen. TERPISAH dari
379
+ // `runs.last_persisted_seq` (watermark penulis), `writer_epoch` (pagar
380
+ // mutasi), dan `presentation_events.event_seq` (kepala kanonik) — empat
381
+ // angka yang sering tertukar; kontrak melarang menggabungkannya karena
382
+ // offset konsumen = "sudah diproses", bukan "sudah ditulis"/"punya siapa".
383
+ //
384
+ // daemon_approvals: mesin persetujuan durable. `state` dkk. — UI hanya
385
+ // MENGUSULKAN keputusan; baris ini adalah otoritasnya.
386
+ withBusyRetrySync(() => {
387
+ db.exec(`
388
+ CREATE TABLE IF NOT EXISTS consumer_offsets (
389
+ consumer_id TEXT NOT NULL,
390
+ session_id TEXT NOT NULL,
391
+ last_acked_seq INTEGER NOT NULL DEFAULT -1,
392
+ updated_at INTEGER NOT NULL,
393
+ PRIMARY KEY(consumer_id, session_id),
394
+ CHECK(last_acked_seq >= -1)
395
+ );
396
+ CREATE INDEX IF NOT EXISTS idx_consumer_offsets_session ON consumer_offsets(session_id);
397
+ CREATE TABLE IF NOT EXISTS daemon_approvals (
398
+ approval_id TEXT PRIMARY KEY,
399
+ session_id TEXT NOT NULL,
400
+ run_id TEXT NULL,
401
+ tool TEXT NOT NULL,
402
+ summary TEXT NOT NULL DEFAULT '',
403
+ state TEXT NOT NULL,
404
+ requested_at INTEGER NOT NULL,
405
+ expires_at INTEGER NULL,
406
+ decided_at INTEGER NULL,
407
+ decision TEXT NULL,
408
+ incarnation TEXT NOT NULL,
409
+ args_hash TEXT NULL,
410
+ invocation_id TEXT NULL
411
+ );
412
+ CREATE INDEX IF NOT EXISTS idx_daemon_approvals_session ON daemon_approvals(session_id, requested_at);
413
+ CREATE INDEX IF NOT EXISTS idx_daemon_approvals_state ON daemon_approvals(state);
414
+ `)
415
+ })
416
+ // [Fase 2 / LOOP-INV-08] Migrasi aditif untuk DB lama: kolom pengikat
417
+ // approval. `PRAGMA table_info` + `ALTER TABLE` idempoten, tanpa
418
+ // user_version (konvensi yang sama dengan migrasi lain di file ini).
419
+ // Baris lama mendapat NULL = "tanpa pengikat" dan tetap terbaca; validasi
420
+ // pengikatan memperlakukan NULL sebagai tidak cocok bila sisi eksekusi
421
+ // membawa hash (fail-closed), bukan sebagai izin.
422
+ try {
423
+ const approvalCols = db.prepare("PRAGMA table_info(daemon_approvals)").all() as {
424
+ name: string
425
+ }[]
426
+ if (!approvalCols.some((c) => c.name === "args_hash")) {
427
+ db.exec("ALTER TABLE daemon_approvals ADD COLUMN args_hash TEXT NULL")
428
+ }
429
+ if (!approvalCols.some((c) => c.name === "invocation_id")) {
430
+ db.exec("ALTER TABLE daemon_approvals ADD COLUMN invocation_id TEXT NULL")
431
+ }
432
+ } catch (e) {
433
+ process.stderr.write(
434
+ `[warn] persistence: daemon_approvals migration skipped: ${(e as Error).message}\n`,
435
+ )
436
+ }
437
+ migratedSessionPaths.add(p)
57
438
  }
58
- db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC)`)
59
- } catch (e) {
60
- process.stderr.write(
61
- `[warn] persistence: sessions migration skipped: ${(e as Error).message}\n`,
439
+ return db
440
+ } catch (err) {
441
+ try {
442
+ db.close()
443
+ } catch {}
444
+ throw err
445
+ }
446
+ }
447
+
448
+ // P2.12 — gerbang terbuka untuk pemilik skema lain (toko konsumen/persetujuan
449
+ // daemon) yang butuh handle lengkap: WAL + busy_timeout + DDL yang sama.
450
+ // Sengaja diekspos sebagai fungsi, bukan `open` sendiri, agar setiap pemanggil
451
+ // tetap melewati satu jalur setup yang sama.
452
+ export function openSessionDb(cwd?: string): Database {
453
+ return open(cwd)
454
+ }
455
+
456
+ // P2.12 — sessions.db milik SATU workspace. Beda dari `openSessionDb` di atas:
457
+ // tak pernah jatuh ke `~/.minicode` global. Dipakai toko daemon (offset
458
+ // konsumen + persetujuan) karena keduanya menyatakan keadaan SATU workspace;
459
+ // menjatuhkannya ke DB bersama membuat konsumen workspace lain "melanjutkan"
460
+ // dari progres yang bukan miliknya — dan tak ada yang bisa membedakannya.
461
+ export function openWorkspaceSessionDb(cwd?: string): Database {
462
+ return open(cwd, true)
463
+ }
464
+
465
+ // P2.2 — penolakan penulis basi. BEDA dari SQLITE_BUSY (masih boleh retry):
466
+ // epoch tak cocok = otoritas telah pindah; retry buta hanya menimpa penulis
467
+ // baru. Pemanggil wajib fail-closed (diagnostik eksplisit), bukan retry.
468
+ export class StaleWriterError extends Error {
469
+ readonly code = "REFUSED_STALE_EPOCH"
470
+ readonly sessionId: string
471
+ readonly expectedEpoch: number
472
+ readonly actualEpoch: number
473
+ constructor(sessionId: string, expectedEpoch: number, actualEpoch: number) {
474
+ super(
475
+ `[persist] REFUSED_STALE_EPOCH sid=${sessionId} expected=${expectedEpoch} actual=${actualEpoch} — authority moved; history NOT durable`,
62
476
  )
477
+ this.name = "StaleWriterError"
478
+ this.sessionId = sessionId
479
+ this.expectedEpoch = expectedEpoch
480
+ this.actualEpoch = actualEpoch
63
481
  }
482
+ }
483
+
484
+ // P2.2 — baca pagar generasi penulis (0 bila baris belum ada: nilai awal
485
+ // deterministik untuk sesi yang belum pernah persist).
486
+ export function readWriterEpoch(id: string, cwd?: string): number {
487
+ const db = open(cwd)
64
488
  try {
65
- const msgCols = db.prepare("PRAGMA table_info(messages)").all() as { name: string }[]
66
- if (!msgCols.some((c) => c.name === "toolCallId")) {
67
- db.exec("ALTER TABLE messages ADD COLUMN toolCallId TEXT")
68
- db.exec("ALTER TABLE messages ADD COLUMN name TEXT")
69
- }
70
- } catch (e) {
71
- process.stderr.write(
72
- `[warn] persistence: messages migration skipped: ${(e as Error).message}\n`,
489
+ const row = db.prepare("SELECT writer_epoch AS epoch FROM sessions WHERE id = ?").get(id) as {
490
+ epoch: number | null
491
+ } | null
492
+ return row?.epoch ?? 0
493
+ } finally {
494
+ db.close()
495
+ }
496
+ }
497
+
498
+ // Verifikasi pagar DI DALAM transaksi pemanggil. Melempar StaleWriterError
499
+ // (rollback oleh txn) bila: baris tak ada padahal ekspektasi > 0 (dunia
500
+ // bergerak: sesi dihapus/dibuat ulang), atau epoch tak cocok.
501
+ function assertWriterEpochInTxn(db: Database, id: string, expectedEpoch: number): void {
502
+ const row = db.prepare("SELECT writer_epoch AS epoch FROM sessions WHERE id = ?").get(id) as {
503
+ epoch: number | null
504
+ } | null
505
+ const actual = row?.epoch ?? 0
506
+ if (row !== null && actual !== expectedEpoch) {
507
+ throw new StaleWriterError(id, expectedEpoch, actual)
508
+ }
509
+ if (row === null && expectedEpoch !== 0) {
510
+ throw new StaleWriterError(id, expectedEpoch, actual)
511
+ }
512
+ }
513
+ // array ribuan angka — cukup placeholder agar DB tidak menggembung.
514
+ // Bentuk lama P2.3 terdeteksi dari PK: [thread_id] saja (threads) atau
515
+ // absennya kolom session_id (history_projections). Bentuk baru / tak-ada
516
+ // tabel → false (CREATE IF NOT EXISTS cukup).
517
+ function threadsTableNeedsP24Rebuild(db: Database): boolean {
518
+ try {
519
+ const cols = db.prepare("PRAGMA table_info(threads)").all() as { name: string; pk: number }[]
520
+ if (cols.length === 0) return false
521
+ const pk = cols
522
+ .filter((c) => c.pk > 0)
523
+ .sort((a, b) => a.pk - b.pk)
524
+ .map((c) => c.name)
525
+ return !(pk.length === 2 && pk[0] === "session_id" && pk[1] === "thread_id")
526
+ } catch {
527
+ return false
528
+ }
529
+ }
530
+
531
+ function projectionsTableNeedsP24Rebuild(db: Database): boolean {
532
+ try {
533
+ const cols = db.prepare("PRAGMA table_info(history_projections)").all() as { name: string }[]
534
+ if (cols.length === 0) return false
535
+ return !cols.some((c) => c.name === "session_id")
536
+ } catch {
537
+ return false
538
+ }
539
+ }
540
+
541
+ // P2.4 — penolak rebuild destruktif. Dipakai HANYA untuk tabel kerangka
542
+ // P2.3 yang dijamin kosong (netralitas runtime + guard): bila ada baris,
543
+ // rebuild DITOLAK loud (tak pernah hapus data diam-diam). Tabel tak-ada =
544
+ // aman (belum pernah dibuat).
545
+ function assertEmptyTableForRebuild(db: Database, table: string): void {
546
+ let exists = false
547
+ try {
548
+ const row = db
549
+ .prepare("SELECT 1 AS ok FROM sqlite_master WHERE type = 'table' AND name = ?")
550
+ .get(table) as { ok: number } | null
551
+ exists = row !== null
552
+ } catch {
553
+ return
554
+ }
555
+ if (!exists) return
556
+ const n = (db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get() as { n: number }).n
557
+ if (n > 0) {
558
+ throw new Error(
559
+ `[persistence] refusing to rebuild non-empty table ${table} (${n} rows) — migrate, never destroy`,
73
560
  )
74
561
  }
75
- return db
76
562
  }
77
563
 
78
564
  // JSON-safe serialization: konten binary (Uint8Array) jangan di-stringify jadi
@@ -94,17 +580,416 @@ function safeContent(value: unknown): string {
94
580
  }
95
581
  }
96
582
 
583
+ const MAX_STORED_EVENT_CHARS = 200_000
584
+ const MAX_STORED_STRING_CHARS = 32_000
585
+
586
+ function stripAnsi(value: string): string {
587
+ let out = ""
588
+ for (let i = 0; i < value.length; i++) {
589
+ const code = value.charCodeAt(i)
590
+ if (code === 27) {
591
+ const next = value[i + 1]
592
+ if (next === "[") {
593
+ i += 2
594
+ while (i < value.length) {
595
+ const current = value.charCodeAt(i)
596
+ if (current >= 0x40 && current <= 0x7e) break
597
+ i++
598
+ }
599
+ continue
600
+ }
601
+ if (next === "]" || next === "P" || next === "_" || next === "^" || next === "X") {
602
+ i += 2
603
+ while (i < value.length) {
604
+ if (value.charCodeAt(i) === 7) break
605
+ if (value.charCodeAt(i) === 27 && value[i + 1] === "\\") {
606
+ i++
607
+ break
608
+ }
609
+ i++
610
+ }
611
+ continue
612
+ }
613
+ continue
614
+ }
615
+ if ((code < 32 && code !== 9 && code !== 10 && code !== 13) || code === 127) continue
616
+ out += value[i]
617
+ }
618
+ return out
619
+ }
620
+
621
+ function scrubStoredValue(value: unknown): unknown {
622
+ if (typeof value === "string") {
623
+ const clean = stripAnsi(scrubSecrets(value))
624
+ return clean.length > MAX_STORED_STRING_CHARS
625
+ ? `${clean.slice(0, MAX_STORED_STRING_CHARS)}…[truncated]`
626
+ : clean
627
+ }
628
+ if (Array.isArray(value)) return value.slice(0, 1000).map((item) => scrubStoredValue(item))
629
+ if (value && typeof value === "object") {
630
+ const out: Record<string, unknown> = {}
631
+ for (const [key, item] of Object.entries(value as Record<string, unknown>)) {
632
+ out[key] = scrubStoredValue(item)
633
+ }
634
+ return out
635
+ }
636
+ return value
637
+ }
638
+
639
+ function encodePresentationEvent(event: DomainEvent): string {
640
+ const value = scrubStoredValue(event) as Record<string, unknown>
641
+ let encoded = JSON.stringify(value)
642
+ if (encoded.length > MAX_STORED_EVENT_CHARS) {
643
+ for (const key of ["message", "summary", "action", "cause", "text", "content"]) {
644
+ if (typeof value[key] === "string")
645
+ value[key] = `[omitted: ${String(value[key]).length} chars]`
646
+ }
647
+ encoded = JSON.stringify(value)
648
+ }
649
+ if (encoded.length > MAX_STORED_EVENT_CHARS) {
650
+ encoded = JSON.stringify({
651
+ eventSeq: event.eventSeq,
652
+ ts: event.ts,
653
+ sessionId: event.sessionId,
654
+ turnId: event.turnId,
655
+ type: event.type,
656
+ truncated: true,
657
+ })
658
+ }
659
+ return encoded
660
+ }
661
+
662
+ function rebasePresentationPayload(payload: string, from: string, to: string): string {
663
+ try {
664
+ const value = JSON.parse(payload) as Record<string, unknown>
665
+ if (value.sessionId === from) value.sessionId = to
666
+ return JSON.stringify(value)
667
+ } catch {
668
+ return payload
669
+ }
670
+ }
671
+
672
+ /**
673
+ * Bentuk minimum tiap tipe event durable. N4.
674
+ *
675
+ * Sebelumnya `decodePresentationEvent` hanya memeriksa enam field skalar lalu
676
+ * `return value as DomainEvent` — blind cast. Akibatnya event yang lolos
677
+ * validasi tapi bentuknya salah (payload terpotong oleh
678
+ * `encodePresentationEvent`, atau baris yang ditulis proses versi lain) tetap
679
+ * masuk ke `reduce`, dan `reduce` yang membaca field yang tidak ada melempar
680
+ * TypeError. Satu event rusak itu menghapus SELURUH presentation state sesi,
681
+ * karena `setup.ts` menangkap lemparannya di sekitar `rebuildFromDurable`.
682
+ *
683
+ * Aturan: lebih baik membuang satu event daripada kehilangan seluruh state.
684
+ * Pembuangan tidak senyap — `loadPresentationEventsWithStats` menghitungnya.
685
+ */
686
+ function isValidPlanStep(s: unknown): boolean {
687
+ if (!s || typeof s !== "object") return false
688
+ const step = s as { stepId?: unknown; status?: unknown }
689
+ if (typeof step.stepId !== "string") return false
690
+ return PLAN_STEP_STATUSES.has(step.status as string)
691
+ }
692
+
693
+ const PLAN_STEP_STATUSES = new Set(["pending", "active", "completed", "cancelled", "blocked"])
694
+ const PLAN_STATUSES = new Set(["open", "completed", "cancelled"])
695
+
696
+ function isValidEventShape(value: Record<string, unknown>): boolean {
697
+ const isStr = (k: string): boolean => typeof value[k] === "string"
698
+ const isNum = (k: string): boolean => typeof value[k] === "number"
699
+ const isArr = (k: string): boolean => Array.isArray(value[k])
700
+ switch (value.type) {
701
+ case "plan.updated":
702
+ return (
703
+ isStr("planId") &&
704
+ PLAN_STATUSES.has(value.status as string) &&
705
+ isArr("steps") &&
706
+ (value.steps as unknown[]).every(isValidPlanStep)
707
+ )
708
+ case "tool.started":
709
+ return isStr("toolCallId") && isNum("stepId") && !!value.identity && !!value.argsSummary
710
+ case "tool.progress":
711
+ case "tool.completed":
712
+ case "tool.failed":
713
+ case "tool.denied":
714
+ case "tool.cancelled":
715
+ case "file.changed":
716
+ return isStr("toolCallId") || isArr("paths")
717
+ case "turn.completed":
718
+ return !!value.summary
719
+ case "turn.failed":
720
+ case "turn.cancelled":
721
+ case "user.message":
722
+ case "turn.started":
723
+ case "checkpoint.created":
724
+ return true
725
+ case "model.delta":
726
+ case "reasoning.delta":
727
+ return isStr("delta")
728
+ case "model.completed":
729
+ case "reasoning.completed":
730
+ return isStr("text")
731
+ case "approval.requested":
732
+ return isStr("approvalId")
733
+ case "approval.settled":
734
+ return isStr("approvalId") && !!value.outcome
735
+ case "test.completed":
736
+ return isNum("passed") && isNum("failed")
737
+ case "verification.observed":
738
+ return (
739
+ isStr("toolCallId") &&
740
+ isStr("invocationId") &&
741
+ (value.verdict === "present" ||
742
+ value.verdict === "absent" ||
743
+ value.verdict === "inconclusive") &&
744
+ isStr("method") &&
745
+ isNum("observedAt")
746
+ )
747
+ case "context.compacted":
748
+ return isStr("reason")
749
+ case "finding.detected":
750
+ return isStr("findingId") && isStr("category")
751
+ case "result.produced":
752
+ return isStr("resultId") && !!value.status
753
+ case "diagnostic.raised":
754
+ return isStr("category") && isStr("message")
755
+ default:
756
+ return true
757
+ }
758
+ }
759
+
760
+ function decodePresentationEvent(payload: string): DomainEvent | null {
761
+ try {
762
+ const value = JSON.parse(payload) as Partial<DomainEvent>
763
+ if (
764
+ typeof value !== "object" ||
765
+ value === null ||
766
+ typeof value.type !== "string" ||
767
+ !DURABILITY[value.type]?.durable ||
768
+ typeof value.eventSeq !== "number" ||
769
+ typeof value.ts !== "number" ||
770
+ typeof value.sessionId !== "string" ||
771
+ typeof value.turnId !== "number"
772
+ )
773
+ return null
774
+ // Stub hasil truncate (`encodePresentationEvent`) hanya punya Base +
775
+ // `truncated`. Tolak eksplisit supaya tidak pernah sampai ke `reduce`.
776
+ if ((value as { truncated?: unknown }).truncated === true) return null
777
+ if (!isValidEventShape(value as unknown as Record<string, unknown>)) return null
778
+ return value as DomainEvent
779
+ } catch {
780
+ return null
781
+ }
782
+ }
783
+
784
+ export interface PresentationEventLoad {
785
+ events: DomainEvent[]
786
+ /** Baris yang dibuang `decodePresentationEvent`. N4: tidak boleh senyap. */
787
+ rejected: number
788
+ }
789
+
790
+ export function loadPresentationEventsWithStats(id: string, cwd?: string): PresentationEventLoad {
791
+ const db = open(cwd)
792
+ try {
793
+ const rows = db
794
+ .prepare("SELECT payload FROM presentation_events WHERE session_id = ? ORDER BY event_seq")
795
+ .all(id) as { payload: string }[]
796
+ const events: DomainEvent[] = []
797
+ let rejected = 0
798
+ for (const row of rows) {
799
+ const event = decodePresentationEvent(row.payload)
800
+ if (event) events.push(event)
801
+ else rejected++
802
+ }
803
+ return { events, rejected }
804
+ } finally {
805
+ db.close()
806
+ }
807
+ }
808
+
809
+ export function loadPresentationEvents(id: string, cwd?: string): DomainEvent[] {
810
+ return loadPresentationEventsWithStats(id, cwd).events
811
+ }
812
+
813
+ // P2.12 — baca rentang untuk replay konsumen. WAJIB ada: `loadPresentationEvents`
814
+ // memuat SELURUH riwayat ke memori, dan konsumen yang attach dengan offset lama
815
+ // akan menarik seluruh sesi (ratusan ribu baris) hanya untuk 200 event terakhir
816
+ // yang belum diproses. Rentang + LIMIT membuat pemakaian memori daemon terikat
817
+ // pada apa yang benar-benar diminta, bukan pada usia sesi.
818
+ export interface PresentationEventRange {
819
+ events: DomainEvent[]
820
+ rejected: number
821
+ /** Kepala kanonik sesi saat baca (untuk memastikan replay tak meleset). */
822
+ head: number
823
+ }
824
+
825
+ export function loadPresentationEventsRange(
826
+ id: string,
827
+ fromSeq: number,
828
+ limit: number,
829
+ cwd?: string,
830
+ ): PresentationEventRange {
831
+ const db = open(cwd)
832
+ try {
833
+ const head = presentationHead(id, cwd, db)
834
+ const capped = Math.max(1, Math.min(Number.isInteger(limit) ? limit : 200, 1000))
835
+ // Clamp ke >= 0 (bukan 1): eventSeq kanonik dimulai dari 1 pada jalur
836
+ // produksi, tapi memotong pada 1 akan menjatuhkan baris 0 bila ada — dan
837
+ // replay yang kehilangan SATU event pertama sudah cukup untuk merusak
838
+ // urutan yang dijanjikan konsumen.
839
+ const start = Number.isInteger(fromSeq) && fromSeq > 0 ? fromSeq : 0
840
+ const rows = db
841
+ .prepare(
842
+ "SELECT payload FROM presentation_events WHERE session_id = ? AND event_seq >= ? ORDER BY event_seq LIMIT ?",
843
+ )
844
+ .all(id, start, capped) as { payload: string }[]
845
+ const events: DomainEvent[] = []
846
+ let rejected = 0
847
+ for (const row of rows) {
848
+ const event = decodePresentationEvent(row.payload)
849
+ if (event) events.push(event)
850
+ else rejected++
851
+ }
852
+ return { events, rejected, head }
853
+ } finally {
854
+ db.close()
855
+ }
856
+ }
857
+
858
+ /**
859
+ * Kepala `presentation_events` (seq tertinggi). `-1` bila belum ada event —
860
+ * -1 = "tak ada", bukan 0 (seq mulai dari 1; 0 akan disalahartikan sebagai
861
+ * "satu event sudah terkirim").
862
+ */
863
+ export function presentationHead(id: string, cwd?: string, reuse?: Database): number {
864
+ const db = reuse ?? open(cwd)
865
+ const owned = reuse === undefined
866
+ try {
867
+ const row = db
868
+ .prepare("SELECT MAX(event_seq) AS head FROM presentation_events WHERE session_id = ?")
869
+ .get(id) as { head: number | null } | null
870
+ return row?.head ?? -1
871
+ } finally {
872
+ if (owned) db.close()
873
+ }
874
+ }
875
+
876
+ /**
877
+ * Kepala `messages` lintas thread (bukan per-thread): frontier konsumen harus
878
+ * mewakili seluruh sesi, dan memilih satu thread akan membuat sesi dengan fork
879
+ * terlihat "mandek" padahal terus menulis di thread lain.
880
+ * `-1` bila belum ada pesan (sama alasan dengan `presentationHead`).
881
+ */
882
+ export function messageHead(id: string, cwd?: string): number {
883
+ const db = open(cwd)
884
+ try {
885
+ const row = db
886
+ .prepare("SELECT MAX(seq) AS head FROM messages WHERE session_id = ?")
887
+ .get(id) as { head: number | null } | null
888
+ return row?.head ?? -1
889
+ } finally {
890
+ db.close()
891
+ }
892
+ }
893
+
894
+ export interface PresentationPersistStats {
895
+ written: number
896
+ duplicates: number
897
+ collisions: number
898
+ }
899
+
900
+ /**
901
+ * Representasi kanonis satu payload untuk perbandingan identitas P2.11:
902
+ * stringify JSON dengan kunci terurut rekursif. Perbandingan string mentah
903
+ * tidak stabil (urutan kunci sisipan bisa berbeda untuk payload yang sama),
904
+ * jadi retransmisi identik harus dibandingkan dalam bentuk kanonis ini.
905
+ */
906
+ export function canonicalizePresentationPayload(value: unknown): string {
907
+ if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null"
908
+ if (Array.isArray(value)) return `[${value.map(canonicalizePresentationPayload).join(",")}]`
909
+ const record = value as Record<string, unknown>
910
+ const keys = Object.keys(record).sort()
911
+ return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalizePresentationPayload(record[key])}`).join(",")}}`
912
+ }
913
+
914
+ /** Bandingkan dua payload tersimpan/ter-encode secara kanonis (tahan urutan kunci). */
915
+ function sameCanonicalPayload(a: string, b: string): boolean {
916
+ if (a === b) return true
917
+ try {
918
+ return (
919
+ canonicalizePresentationPayload(JSON.parse(a)) ===
920
+ canonicalizePresentationPayload(JSON.parse(b))
921
+ )
922
+ } catch {
923
+ return false
924
+ }
925
+ }
926
+
927
+ export async function appendPresentationEvents(
928
+ id: string,
929
+ cwd: string | undefined,
930
+ events: readonly DomainEvent[],
931
+ opts?: { expectedEpoch?: number },
932
+ ): Promise<PresentationPersistStats> {
933
+ const stats: PresentationPersistStats = { written: 0, duplicates: 0, collisions: 0 }
934
+ const durable = events.filter((event) => DURABILITY[event.type]?.durable)
935
+ if (durable.length === 0) return stats
936
+ const db = open(cwd)
937
+ const txn = db.transaction(() => {
938
+ // P2.2: pagar generasi di dalam txn yang sama dengan tulis (bukan
939
+ // check-then-write terpisah). Absennya baris sesi + ekspektasi 0 =
940
+ // sesi pra-save pertama: diizinkan (baris dibuat oleh saveSession).
941
+ if (opts?.expectedEpoch !== undefined) assertWriterEpochInTxn(db, id, opts.expectedEpoch)
942
+ const existing = db.prepare(
943
+ "SELECT payload FROM presentation_events WHERE session_id = ? AND event_seq = ?",
944
+ )
945
+ const insert = db.prepare(
946
+ "INSERT OR IGNORE INTO presentation_events (session_id, event_seq, type, turn_id, ts, payload) VALUES (?, ?, ?, ?, ?, ?)",
947
+ )
948
+ for (const event of durable) {
949
+ const payload = encodePresentationEvent(event)
950
+ // P2.11: bedakan duplikat vs tabrakan pada identitas yang sama.
951
+ // Duplikat (payload kanonis identik) = idempoten, lewati diam-diam.
952
+ // Tabrakan (payload berbeda) = pertahankan baris existing, tolak yang
953
+ // datang, hitung + diagnostik — jangan pernah menimpa, jangan simpulkan
954
+ // apa pun tentang runtime dari tabrakan ini.
955
+ const row = existing.get(id, event.eventSeq) as { payload: string } | undefined
956
+ if (row) {
957
+ if (sameCanonicalPayload(row.payload, payload)) {
958
+ stats.duplicates++
959
+ } else {
960
+ stats.collisions++
961
+ process.stderr.write(
962
+ `[warn] presentation identity collision (session ${id} seq ${event.eventSeq} type ${event.type}): kept existing row, rejected incoming\n`,
963
+ )
964
+ }
965
+ continue
966
+ }
967
+ insert.run(id, event.eventSeq, event.type, event.turnId, event.ts, payload)
968
+ stats.written++
969
+ }
970
+ })
971
+ try {
972
+ await withBusyRetry(() => txn())
973
+ } finally {
974
+ db.close()
975
+ }
976
+ return stats
977
+ }
978
+
97
979
  // SQLITE_BUSY / database-is-locked bisa muncul saat Pool(3) sub-agent menulis
98
980
  // bersamaan meski WAL+busy_timeout aktif (terutama Windows). Retry singkat
99
981
  // P0.2: async + Bun.sleep agar tidak block event-loop (sebelumnya Atomics.wait freeze 175ms).
100
- async function withBusyRetry<T>(fn: () => T, attempts = 3): Promise<T> {
982
+ //
983
+ // Diekspor (seam aditif, bukan refactor) supaya jalur retry bisa diuji langsung.
984
+ // Sebelum ini tidak ada satu pun test yang menyuntik SQLITE_BUSY, sehingga
985
+ // "retry bekerja" adalah klaim tanpa bukti.
986
+ export async function withBusyRetry<T>(fn: () => T, attempts = 3): Promise<T> {
101
987
  let last: unknown
102
988
  for (let i = 0; i < attempts; i++) {
103
989
  try {
104
990
  return fn()
105
991
  } catch (e) {
106
- const msg = String((e as Error).message ?? e)
107
- if (!msg.includes("SQLITE_BUSY") && !msg.includes("database is locked")) throw e
992
+ if (!isSqliteContention(e)) throw e
108
993
  last = e
109
994
  await Bun.sleep(25 * 2 ** i)
110
995
  }
@@ -112,63 +997,98 @@ async function withBusyRetry<T>(fn: () => T, attempts = 3): Promise<T> {
112
997
  throw last
113
998
  }
114
999
 
1000
+ type StoredMsg = {
1001
+ role: string
1002
+ content: unknown
1003
+ toolCalls?: unknown
1004
+ toolCallId?: string
1005
+ name?: string
1006
+ reasoning?: string
1007
+ isError?: boolean
1008
+ }
1009
+ type Norm = [string, string, string, string | null, string | null, string | null, number]
1010
+ function normalizeMessageTupleForDedup(m: StoredMsg): Norm {
1011
+ return [
1012
+ m.role,
1013
+ safeContent(m.content),
1014
+ safeContent(m.toolCalls ?? null),
1015
+ (m.toolCallId ?? null) as string | null,
1016
+ (m.name ?? null) as string | null,
1017
+ // reasoning & is_error WAJIB ikut prefix comparison. Kalau tidak, perubahan
1018
+ // HANYA pada kedua field itu dianggap "tak berubah" dan incremental append
1019
+ // melewatkannya — persis kelas bug F-05.
1020
+ typeof m.reasoning === "string" ? safeContent(m.reasoning) : null,
1021
+ m.isError === true ? 1 : 0,
1022
+ ]
1023
+ }
1024
+
115
1025
  export async function saveSession(
116
1026
  id: string,
117
1027
  cwd: string | undefined,
118
1028
  system: string | undefined,
119
1029
  messages: readonly unknown[],
120
1030
  usage: unknown,
1031
+ // P2.2: pagar mutasi. Disediakan composition root (satu penulis); pemanggil
1032
+ // legacy/test tanpa epoch memakai jalur tak-berpagar (tercatat di guard).
1033
+ // P2.6: runId opsional — baris BARU (bukan adopsi) dicap milik run ini dan
1034
+ // kursor run maju ke head dalam txn yang SAMA (atomik histori+kursor).
1035
+ opts?: { expectedEpoch?: number; runId?: string },
121
1036
  ) {
122
1037
  const db = open(cwd)
123
1038
  const now = Date.now()
124
1039
  const txn = db.transaction(() => {
1040
+ // P2.2: CAS generasi + mutasi = SATU transaksi. Lempar di sini → rollback
1041
+ // total (tak ada tulis parsial), dan withBusyRetry tak menyentuh error ini
1042
+ // (bukan SQLITE_BUSY) sehingga tak ada retry buta.
1043
+ if (opts?.expectedEpoch !== undefined) assertWriterEpochInTxn(db, id, opts.expectedEpoch)
125
1044
  const existing = db
126
1045
  .prepare("SELECT created_at, updated_at FROM sessions WHERE id = ?")
127
1046
  .get(id) as { created_at: number; updated_at: number | null } | null
128
1047
  const createdAt = existing?.created_at ?? now
1048
+ // P2.2: upsert MEMPERTAHANKAN writer_epoch. INSERT OR REPLACE menghapus
1049
+ // lalu menyisipkan ulang (epoch kembali 0!) — dilarang untuk baris sesi.
129
1050
  db.prepare(
130
- "INSERT OR REPLACE INTO sessions (id, created_at, updated_at, cwd, system) VALUES (?, ?, ?, ?, ?)",
131
- ).run(id, createdAt, now, cwd ?? "", system ?? "")
1051
+ "INSERT INTO sessions (id, created_at, updated_at, cwd, system, writer_epoch) VALUES (?, ?, ?, ?, ?, COALESCE((SELECT writer_epoch FROM sessions WHERE id = ?), 0)) ON CONFLICT(id) DO UPDATE SET updated_at = excluded.updated_at, cwd = excluded.cwd, system = excluded.system",
1052
+ ).run(id, createdAt, now, cwd ?? "", system ?? "", id)
1053
+ // P2.4: histori dimiliki default Thread — ensure atomik dalam txn yang
1054
+ // sama (sesi + thread tak pernah terpisah; tak ada sesi threadless yang
1055
+ // durable). Backfill NULL aditif; archived menolak tulis (dorman).
1056
+ const thread = ensureDefaultThreadInTxn(db, id, now)
1057
+ if (thread.status === "archived") throw new ThreadArchivedError(id, thread.thread_id)
1058
+ const tid = thread.thread_id
132
1059
  const ins = db.prepare(
133
- "INSERT INTO messages (session_id, seq, role, content, toolCalls, toolCallId, name, ts) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
1060
+ "INSERT INTO messages (session_id, thread_id, seq, role, content, toolCalls, toolCallId, name, reasoning, is_error, ts, event_id, run_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
134
1061
  )
135
- type StoredMsg = {
136
- role: string
137
- content: unknown
138
- toolCalls?: unknown
139
- toolCallId?: string
140
- name?: string
141
- }
142
- const norm = (m: StoredMsg): [string, string, string, string | null, string | null] => [
143
- m.role,
144
- safeContent(m.content),
145
- safeContent(m.toolCalls ?? null),
146
- (m.toolCallId ?? null) as string | null,
147
- (m.name ?? null) as string | null,
148
- ]
1062
+ // StoredMsg/Norm/norm: modul-level (dipakai saveSession + shrinkThreadHistory).
149
1063
  // F-05: JANGAN pakai messages.length sebagai proksi perubahan. Kompaksi
150
1064
  // (atau replace apa pun) bisa mengganti N pesan dengan N pesan BERBEDA —
151
1065
  // panjang sama, isi beda. Tanpa verifikasi prefix, tulis dilewat dan
152
1066
  // resume memuat sejarah basi. Bandingkan prefix tersimpan dengan incoming:
153
1067
  // sama persis = re-save (bukan turn baru, jaga guard anti turn-hantu);
154
1068
  // prefix sama + tumbuh = append; selain itu = rewrite penuh.
1069
+ // P2.4: pembanding prefix dibatasi histori default Thread (inklusif NULL
1070
+ // transisional untuk baris pra-backfill; pasca-backfill tak ada NULL).
155
1071
  const stored = db
156
1072
  .prepare(
157
- "SELECT seq, role, content, toolCalls, toolCallId, name FROM messages WHERE session_id = ? ORDER BY seq",
1073
+ "SELECT seq, role, content, toolCalls, toolCallId, name, reasoning, is_error, event_id, run_id FROM messages WHERE session_id = ? AND (thread_id = ? OR thread_id IS NULL) ORDER BY seq",
158
1074
  )
159
- .all(id) as {
1075
+ .all(id, tid) as {
160
1076
  seq: number
161
1077
  role: string
162
1078
  content: string
163
1079
  toolCalls: string
164
1080
  toolCallId: string | null
165
1081
  name: string | null
1082
+ reasoning: string | null
1083
+ is_error: number | null
1084
+ event_id: string | null
1085
+ run_id: string | null
166
1086
  }[]
167
1087
  const known = stored.length
168
1088
  let prefixSame = stored.length <= messages.length
169
1089
  if (prefixSame) {
170
1090
  for (let i = 0; i < stored.length; i++) {
171
- const want = norm(messages[i] as StoredMsg)
1091
+ const want = normalizeMessageTupleForDedup(messages[i] as StoredMsg)
172
1092
  const got = stored[i]!
173
1093
  if (
174
1094
  got.seq !== i ||
@@ -176,7 +1096,9 @@ export async function saveSession(
176
1096
  got.content !== want[1] ||
177
1097
  got.toolCalls !== want[2] ||
178
1098
  (got.toolCallId ?? null) !== want[3] ||
179
- (got.name ?? null) !== want[4]
1099
+ (got.name ?? null) !== want[4] ||
1100
+ (got.reasoning ?? null) !== want[5] ||
1101
+ (got.is_error ?? 0) !== want[6]
180
1102
  ) {
181
1103
  prefixSame = false
182
1104
  break
@@ -185,21 +1107,92 @@ export async function saveSession(
185
1107
  }
186
1108
  const changed = !prefixSame || stored.length !== messages.length
187
1109
  if (changed && prefixSame) {
188
- // incremental append-only: cukup insert pesan baru (umumnya 1 turn)
1110
+ // incremental append-only: cukup insert pesan baru (umumnya 1 turn).
1111
+ // P2.5: tiap baris baru mendapat event_id fresh SATU KALI di sini;
1112
+ // save ulang identik = no-op (prefixSame) sehingga id stabil.
1113
+ // P2.6: baris baru dicap run_id pemanggil (bila ada).
189
1114
  for (let i = known; i < messages.length; i++) {
190
1115
  const m = messages[i] as StoredMsg
191
- const w = norm(m)
192
- ins.run(id, i, w[0], w[1], w[2], w[3], w[4], now)
1116
+ const w = normalizeMessageTupleForDedup(m)
1117
+ ins.run(
1118
+ id,
1119
+ tid,
1120
+ i,
1121
+ w[0],
1122
+ w[1],
1123
+ w[2],
1124
+ w[3],
1125
+ w[4],
1126
+ w[5],
1127
+ w[6],
1128
+ now,
1129
+ allocateHistoryEventId(),
1130
+ opts?.runId ?? null,
1131
+ )
193
1132
  }
194
1133
  } else if (changed) {
195
- // history menyusut (compaction/reset) ATAU prefix berubah dengan panjang
196
- // sama (kompaksi N→N) → tulis ulang penuh agar tidak ada pesan basi
197
- // yang tertinggal untuk resume
198
- db.prepare("DELETE FROM messages WHERE session_id = ?").run(id)
199
- for (let i = 0; i < messages.length; i++) {
200
- const m = messages[i] as StoredMsg
201
- const w = norm(m)
202
- ins.run(id, i, w[0], w[1], w[2], w[3], w[4], now)
1134
+ // P2.7: saveSession APPEND-ONLY. Riwayat menyusut ATAU prefix berubah
1135
+ // (kompaksi N→N) DITOLAK eksplisit — bukan ditulis ulang diam-diam.
1136
+ // Jalur eksplisit: shrinkThreadHistory (berpagar epoch, menolak run
1137
+ // live, mencatat provenance, menginvalidasi proyeksi, satu txn).
1138
+ // Menghapus cabang DELETE+rewrite implisit menutup jalur destruktif
1139
+ // tanpa provenance (guard P2.7 menegakkannya tetap hilang).
1140
+ // P3.1-retarget: bedakan "kanonik tumbuh melampaui buffer" dari
1141
+ // lipatan/divergensi buffer sendiri — pembedanya dibawa dalam error
1142
+ // (grewBeyondBuffer) agar composition root menolak shrink otomatis pada
1143
+ // kasus pertama. Perbandingan field IDENTIK dengan loop prefix di atas
1144
+ // (F-05); bila loop itu berubah, sinkronkan keduanya.
1145
+ let grewBeyondBuffer = false
1146
+ if (stored.length > messages.length) {
1147
+ grewBeyondBuffer = true
1148
+ for (let i = 0; i < messages.length; i++) {
1149
+ const want = normalizeMessageTupleForDedup(messages[i] as StoredMsg)
1150
+ const got = stored[i]!
1151
+ if (
1152
+ got.seq !== i ||
1153
+ got.role !== want[0] ||
1154
+ got.content !== want[1] ||
1155
+ got.toolCalls !== want[2] ||
1156
+ (got.toolCallId ?? null) !== want[3] ||
1157
+ (got.name ?? null) !== want[4] ||
1158
+ (got.reasoning ?? null) !== want[5] ||
1159
+ (got.is_error ?? 0) !== want[6]
1160
+ ) {
1161
+ grewBeyondBuffer = false
1162
+ break
1163
+ }
1164
+ }
1165
+ }
1166
+ throw new RefusedHistoryRewriteError(
1167
+ id,
1168
+ tid,
1169
+ `stored=${stored.length} incoming=${messages.length} prefixSame=${prefixSame}`,
1170
+ grewBeyondBuffer,
1171
+ )
1172
+ }
1173
+ // P2.4: head cache = MAX(seq) histori thread ini (-1 bila kosong).
1174
+ const head = recomputeThreadHeadInTxn(db, id, tid)
1175
+ // P2.6: kursor run maju ke head DALAM txn yang sama (atomik histori +
1176
+ // kursor: event durable TANPA kursor basi, dan sebaliknya, tak mungkin
1177
+ // terpisah). Baris terminal dibekukan (persist-duplikat pasca-terminal
1178
+ // = no-op aman, bukan pergerakan).
1179
+ if (opts?.runId !== undefined) {
1180
+ // Kepemilikan run diverifikasi (bukan diasumsikan): run milik sesi+thread
1181
+ // lain tidak boleh "menyerap" kursor histori ini.
1182
+ const runRow = db
1183
+ .prepare("SELECT session_id, thread_id FROM runs WHERE run_id = ?")
1184
+ .get(opts.runId) as { session_id: string; thread_id: string } | null
1185
+ if (!runRow) throw new Error(`run not found: ${opts.runId}`)
1186
+ if (runRow.session_id !== id || runRow.thread_id !== tid)
1187
+ throw new Error(`run ${opts.runId} does not belong to ${id}/${tid}`)
1188
+ // Kursor = posisi histori milik run ini. Baris head yang dicap run lain
1189
+ // (atau NULL warisan) tak boleh jadi klaim kursor. Run terminal beku:
1190
+ // persist pasca-terminal = no-op kursor (histori tetap durable).
1191
+ if (head >= 0) {
1192
+ const status = db.prepare("SELECT status FROM runs WHERE run_id = ?").get(opts.runId) as {
1193
+ status: string
1194
+ }
1195
+ if (!RUN_TERMINAL.has(status.status)) advanceRunCursorInTxn(db, opts.runId, head, id)
203
1196
  }
204
1197
  }
205
1198
  if (usage) {
@@ -249,14 +1242,82 @@ export function purgeExpired(db: Database, now = Date.now()): number {
249
1242
  if (days <= 0) return 0
250
1243
  const ttlMs = days * 24 * 60 * 60 * 1000
251
1244
  const cutoff = now - ttlMs
1245
+ // [PHASE 6Q] F6. Collect the expiring ids BEFORE deleting anything, then run
1246
+ // each through the CANONICAL deletion operation.
1247
+ //
1248
+ // Previously this deleted `sessions` and cascaded over the session-side tables
1249
+ // but never touched `tasks.db`, so every TTL-purged session orphaned its task
1250
+ // rows AND their execution lineage - which, after 6P, would include durable
1251
+ // `execution_owner` markers pointing at generations that can never be
1252
+ // reconciled. `deleteSession` had the right behaviour (6K D4) and this did not;
1253
+ // two deletion architectures, one of them a bug.
1254
+ //
1255
+ // `purgeExpired` is SYNC, so the canonical operation is driven synchronously
1256
+ // here: the session-side deletes are the same statements, in one transaction,
1257
+ // in the same order, with the same "tasks first" residue - see
1258
+ // `deleteSessionCompletely` for the full ordering argument. It is shared rather
1259
+ // than duplicated for exactly that reason: 6O ADR-9's rule is ONE deletion
1260
+ // architecture, so the ordering cannot drift between these two entry points.
1261
+ const expiring = db
1262
+ .prepare(`SELECT id FROM sessions WHERE COALESCE(updated_at, created_at) < ?`)
1263
+ .all(cutoff) as { id: string }[]
1264
+
1265
+ const { TaskStore } = require("../task/store.ts") as typeof import("../task/store.ts")
1266
+ const cwd = sessionCwdOf(db, expiring)
1267
+ const tasks = new TaskStore(cwd)
1268
+ for (const row of expiring) {
1269
+ // 1. invalidate in-flight executions, 2. remove task rows.
1270
+ tasks.bumpSessionIncarnation(row.id)
1271
+ tasks.deleteSessionTasks(row.id)
1272
+ }
1273
+
252
1274
  const gone = db
253
1275
  .prepare("DELETE FROM sessions WHERE COALESCE(updated_at, created_at) < ?")
254
1276
  .run(cutoff)
1277
+ // Orphan rows WAJIB selalu dibersihkan — bukan cuma saat sesi expired — karena
1278
+ // yatim bisa hadir out-of-band (crash mid-delete, atau anak tanpa baris sessions).
1279
+ // [Audit #2 C.F2] mengusulkan gate pada `gone.changes > 0`, tapi itu salah:
1280
+ // test `sub-agent-forensic.test.ts` "F" membuktikan yatim `sub_*` (tanpa baris
1281
+ // sessions) harus dibersihkan `purgeExpired` bahkan ketika `gone.changes === 0`.
1282
+ // Gate dibatalkan demi kontrak orphan-cleanup.
255
1283
  db.prepare("DELETE FROM messages WHERE session_id NOT IN (SELECT id FROM sessions)").run()
256
1284
  db.prepare("DELETE FROM turns WHERE session_id NOT IN (SELECT id FROM sessions)").run()
1285
+ // P2.2: yatim alias/takeover ikut dibersihkan (pola orphan yang sama).
1286
+ // Best-effort seperti presentation_events di bawah: handle mentah (purge
1287
+ // CLI, fixture uji) belum tentu punya tabel baru; open() selalu membuatnya.
1288
+ // P2.4: yatim Thread + Run + proyeksi ikut pola yang sama (tabel kosong
1289
+ // hingga P2.5/2.7 menulis; nihil-op hingga saat itu).
1290
+ try {
1291
+ db.prepare("DELETE FROM session_aliases WHERE canonical NOT IN (SELECT id FROM sessions)").run()
1292
+ db.prepare(
1293
+ "DELETE FROM session_takeovers WHERE session_id NOT IN (SELECT id FROM sessions)",
1294
+ ).run()
1295
+ db.prepare("DELETE FROM threads WHERE session_id NOT IN (SELECT id FROM sessions)").run()
1296
+ db.prepare("DELETE FROM runs WHERE session_id NOT IN (SELECT id FROM sessions)").run()
1297
+ db.prepare(
1298
+ "DELETE FROM history_projections WHERE session_id NOT IN (SELECT id FROM sessions)",
1299
+ ).run()
1300
+ } catch {}
1301
+ try {
1302
+ db.prepare(
1303
+ "DELETE FROM presentation_events WHERE session_id NOT IN (SELECT id FROM sessions)",
1304
+ ).run()
1305
+ } catch {}
257
1306
  return gone.changes
258
1307
  }
259
1308
 
1309
+ /** The workspace directory recorded on the expiring sessions, for TaskStore. */
1310
+ function sessionCwdOf(db: Database, rows: { id: string }[]): string | undefined {
1311
+ for (const r of rows) {
1312
+ const row = db.prepare("SELECT cwd FROM sessions WHERE id = ?").get(r.id) as
1313
+ | { cwd: string | null }
1314
+ | null
1315
+ | undefined
1316
+ if (row?.cwd) return row.cwd
1317
+ }
1318
+ return undefined
1319
+ }
1320
+
260
1321
  function parseContent(s: string): unknown {
261
1322
  try {
262
1323
  return JSON.parse(s)
@@ -265,6 +1326,48 @@ function parseContent(s: string): unknown {
265
1326
  }
266
1327
  }
267
1328
 
1329
+ type StoredMessageRow = {
1330
+ seq: number
1331
+ role: string
1332
+ content: string
1333
+ toolCalls: string
1334
+ toolCallId: string | null
1335
+ name: string | null
1336
+ reasoning: string | null
1337
+ is_error: number | null
1338
+ }
1339
+
1340
+ // P2.4: dekoder baris→pesan TUNGGAL (dipakai loadSession kompatibel +
1341
+ // loadThreadHistory ketat). Satu jalur decode = tak ada divergensi bentuk.
1342
+ function decodeMessageRows(rows: StoredMessageRow[]): unknown[] {
1343
+ // `reasoning` ditulis lewat safeContent (JSON) supaya ikut scrub + cap
1344
+ // seperti `content`, jadi dibalik simetris di sini. String kosong
1345
+ // diperlakukan absen: menyetel `reasoning: ""` / `isError: false` di setiap
1346
+ // pesan akan mengubah bentuk pesan saat kernel membandingkan.
1347
+ const readReasoning = (raw: string | null): string | undefined => {
1348
+ if (!raw) return undefined
1349
+ const parsed = parseContent(raw)
1350
+ return typeof parsed === "string" && parsed.length > 0 ? parsed : undefined
1351
+ }
1352
+ return rows.map((r) => {
1353
+ const reasoning = readReasoning(r.reasoning)
1354
+ // [ST-2] toolCalls WAJIB array: kolom korup (bukan array) dikembalikan
1355
+ // undefined, BUKAN string mentah, agar `message.toolCalls.map(...)` di
1356
+ // kernel tak melempar TypeError saat resume.
1357
+ const rawToolCalls =
1358
+ r.toolCalls && r.toolCalls !== "null" ? parseContent(r.toolCalls) : undefined
1359
+ return {
1360
+ role: r.role,
1361
+ content: parseContent(r.content),
1362
+ ...(Array.isArray(rawToolCalls) ? { toolCalls: rawToolCalls } : {}),
1363
+ ...(r.toolCallId ? { toolCallId: r.toolCallId } : {}),
1364
+ ...(r.name ? { name: r.name } : {}),
1365
+ ...(reasoning ? { reasoning } : {}),
1366
+ ...(r.is_error === 1 ? { isError: true } : {}),
1367
+ }
1368
+ })
1369
+ }
1370
+
268
1371
  export function loadSession(
269
1372
  id: string,
270
1373
  cwd?: string,
@@ -274,24 +1377,20 @@ export function loadSession(
274
1377
  const sess = db.prepare("SELECT * FROM sessions WHERE id = ?").get(id) as {
275
1378
  system: string
276
1379
  cwd: string
1380
+ default_thread_id: string | null
277
1381
  } | null
278
1382
  if (!sess) {
279
1383
  return null
280
1384
  }
281
- const rows = db.prepare("SELECT * FROM messages WHERE session_id = ? ORDER BY seq").all(id) as {
282
- role: string
283
- content: string
284
- toolCalls: string
285
- toolCallId: string | null
286
- name: string | null
287
- }[]
288
- const messages = rows.map((r) => ({
289
- role: r.role,
290
- content: parseContent(r.content),
291
- ...(r.toolCalls && r.toolCalls !== "null" ? { toolCalls: parseContent(r.toolCalls) } : {}),
292
- ...(r.toolCallId ? { toolCallId: r.toolCallId } : {}),
293
- ...(r.name ? { name: r.name } : {}),
294
- }))
1385
+ // P2.4: histori sesi = histori default Thread (inklusif NULL transisional
1386
+ // untuk baris pra-backfill; baca kompatibel, bukan identitas ganda).
1387
+ const tid = sess.default_thread_id ?? DEFAULT_THREAD_ID
1388
+ const rows = db
1389
+ .prepare(
1390
+ "SELECT * FROM messages WHERE session_id = ? AND (thread_id = ? OR thread_id IS NULL) ORDER BY seq",
1391
+ )
1392
+ .all(id, tid) as StoredMessageRow[]
1393
+ const messages = decodeMessageRows(rows)
295
1394
  const turnRow = db
296
1395
  .prepare("SELECT MAX(turn_idx) as m FROM turns WHERE session_id = ?")
297
1396
  .get(id) as { m: number | null } | null
@@ -302,8 +1401,43 @@ export function loadSession(
302
1401
  }
303
1402
  }
304
1403
 
305
- export function listPersistedTurns(id: string, cwd?: string): number[] {
306
- // Turn durable untuk keputusan recovery journal (baca-saja, tanpa schema).
1404
+ // P2.4: baca histori SATU thread (ketat: tanpa NULL transisional).
1405
+ // Beda dari loadSession (kompatibel): di sini thread scope eksplisit.
1406
+ export function loadThreadHistory(sessionId: string, threadId: string, cwd?: string): unknown[] {
1407
+ const db = open(cwd)
1408
+ try {
1409
+ const rows = db
1410
+ .prepare("SELECT * FROM messages WHERE session_id = ? AND thread_id = ? ORDER BY seq")
1411
+ .all(sessionId, threadId) as StoredMessageRow[]
1412
+ return decodeMessageRows(rows)
1413
+ } finally {
1414
+ db.close()
1415
+ }
1416
+ }
1417
+
1418
+ // P2.8 — pembaca histori thread YANG membawa seq. Beda dari loadThreadHistory
1419
+ // (tanpa seq): konsumen komposisi konteks butuh tahu posisi persis tiap baris
1420
+ // (batas [0,base_seq) vs ekor) tanpa mengira indeks = seq. Aditif, baca-saja,
1421
+ // thread-scoped — tanpa ini perakitan konteks akan menebak.
1422
+ export function loadThreadHistoryWithSeq(
1423
+ sessionId: string,
1424
+ threadId: string,
1425
+ cwd?: string,
1426
+ ): { seq: number; message: unknown }[] {
1427
+ const db = open(cwd)
1428
+ try {
1429
+ const rows = db
1430
+ .prepare("SELECT * FROM messages WHERE session_id = ? AND thread_id = ? ORDER BY seq")
1431
+ .all(sessionId, threadId) as StoredMessageRow[]
1432
+ const decoded = decodeMessageRows(rows)
1433
+ return decoded.map((message, i) => ({ seq: rows[i]!.seq, message }))
1434
+ } finally {
1435
+ db.close()
1436
+ }
1437
+ }
1438
+
1439
+ export function listPersistedTurns(id: string, cwd?: string): number[] {
1440
+ // Turn durable untuk keputusan recovery journal (baca-saja, tanpa schema).
307
1441
  const db = open(cwd)
308
1442
  try {
309
1443
  const rows = db
@@ -315,34 +1449,2261 @@ export function listPersistedTurns(id: string, cwd?: string): number[] {
315
1449
  }
316
1450
  }
317
1451
 
318
- export function listSessions(
1452
+ export interface SessionUsageSummary {
1453
+ inputTokens: number
1454
+ outputTokens: number
1455
+ totalTokens: number
1456
+ cacheReadTokens: number
1457
+ cacheWriteTokens: number
1458
+ /**
1459
+ * Hanya terisi bila seluruh turn ber-token pada sesi memiliki biaya numerik.
1460
+ * Bila ada turn ber-token tanpa harga (`cost == null`), dibiarkan `undefined`
1461
+ * supaya invariant fail-closed F-06 (`unknown-strict`) tetap berlaku lintas resume.
1462
+ */
1463
+ totalCostUsd?: number
1464
+ turnCount: number
1465
+ }
1466
+
1467
+ /**
1468
+ * [Fase 3 / LOOP-INV-11] Agregasi pemakaian historis sesi dari tabel `turns`.
1469
+ * Dipakai saat `--resume` untuk meng-seed `createUsageCollector` sehingga
1470
+ * budget token/USD dan `turnCount` tidak ter-reset ke nol saat restart.
1471
+ */
1472
+ export function loadSessionUsageSummary(id: string, cwd?: string): SessionUsageSummary {
1473
+ const db = open(cwd)
1474
+ try {
1475
+ const rows = db
1476
+ .prepare("SELECT turn_idx, usage FROM turns WHERE session_id = ? ORDER BY turn_idx")
1477
+ .all(id) as { turn_idx: number; usage: string | null }[]
1478
+ let inputTokens = 0
1479
+ let outputTokens = 0
1480
+ let totalTokens = 0
1481
+ let cacheReadTokens = 0
1482
+ let cacheWriteTokens = 0
1483
+ let costSum = 0
1484
+ let sawPricedSegment = false
1485
+ let sawUnpricedTokenSegment = false
1486
+ let maxTurnIdx = -1
1487
+
1488
+ const nonNeg = (v: unknown): number =>
1489
+ typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0
1490
+
1491
+ for (const r of rows) {
1492
+ if (typeof r.turn_idx === "number" && r.turn_idx > maxTurnIdx) maxTurnIdx = r.turn_idx
1493
+ if (!r.usage) continue
1494
+ let parsed: Record<string, unknown> | null = null
1495
+ try {
1496
+ parsed = JSON.parse(r.usage) as Record<string, unknown>
1497
+ } catch {
1498
+ continue
1499
+ }
1500
+ if (!parsed || typeof parsed !== "object") continue
1501
+ const inp = nonNeg(parsed.inputTokens)
1502
+ const out = nonNeg(parsed.outputTokens)
1503
+ const tot = Math.max(inp + out, nonNeg(parsed.totalTokens))
1504
+ inputTokens += inp
1505
+ outputTokens += out
1506
+ totalTokens += tot
1507
+ cacheReadTokens += nonNeg(parsed.cacheReadTokens)
1508
+ cacheWriteTokens += nonNeg(parsed.cacheWriteTokens)
1509
+ if (typeof parsed.cost === "number" && Number.isFinite(parsed.cost) && parsed.cost >= 0) {
1510
+ costSum += parsed.cost
1511
+ sawPricedSegment = true
1512
+ } else if (tot > 0) {
1513
+ sawUnpricedTokenSegment = true
1514
+ }
1515
+ }
1516
+
1517
+ const turnCount = maxTurnIdx >= 0 ? maxTurnIdx + 1 : 0
1518
+ const totalCostUsd = !sawUnpricedTokenSegment && sawPricedSegment ? costSum : undefined
1519
+ return {
1520
+ inputTokens,
1521
+ outputTokens,
1522
+ totalTokens,
1523
+ cacheReadTokens,
1524
+ cacheWriteTokens,
1525
+ ...(totalCostUsd !== undefined ? { totalCostUsd } : {}),
1526
+ turnCount,
1527
+ }
1528
+ } finally {
1529
+ db.close()
1530
+ }
1531
+ }
1532
+
1533
+ export function listSessions(
1534
+ cwd?: string,
1535
+ ): { id: string; created_at: number; updated_at?: number; cwd: string }[] {
1536
+ const db = open(cwd)
1537
+ try {
1538
+ const rows = db
1539
+ .prepare(
1540
+ "SELECT id, created_at, updated_at, cwd FROM sessions ORDER BY COALESCE(updated_at, created_at) DESC LIMIT 50",
1541
+ )
1542
+ .all() as { id: string; created_at: number; updated_at: number | null; cwd: string }[]
1543
+ return rows.map((r) => ({ ...r, updated_at: r.updated_at ?? r.created_at }))
1544
+ } finally {
1545
+ db.close()
1546
+ }
1547
+ }
1548
+
1549
+ /**
1550
+ * [P14.2] Baca meta baris sesi (id + timestamps) TANPA membuat berkas DB.
1551
+ *
1552
+ * `open()` membuat sessions.db saat belum ada — itu benar untuk jalur tulis,
1553
+ * tetapi PROYEKSI read-only tidak boleh meninggalkan berkas hanya karena
1554
+ * dibaca. `existsSync` dipakai sebagai pagar: berkas tak ada = semua sesi
1555
+ * dianggap "meta tidak diketahui" (provenance UNKNOWN), bukan error.
1556
+ *
1557
+ * `resolveDbPath` (bukan local-only) dipakai dengan sengaja: sama dengan
1558
+ * resolusi yang dipakai `saveSession`, jadi meta yang dibaca proyeksi
1559
+ * dan meta yang ditulis lifecycle tak bisa berbeda domain.
1560
+ */
1561
+ export function readSessionMetaRows(
1562
+ cwd?: string,
1563
+ ): { id: string; created_at: number; updated_at: number }[] {
1564
+ const p = dbPath(cwd)
1565
+ if (!existsSync(p)) return []
1566
+ const db = new Database(p)
1567
+ try {
1568
+ const rows = db
1569
+ .prepare(
1570
+ "SELECT id, created_at, COALESCE(updated_at, created_at) AS updated_at FROM sessions",
1571
+ )
1572
+ .all() as { id: string; created_at: number; updated_at: number }[]
1573
+ return rows
1574
+ } catch {
1575
+ // DB rusak/tak terbaca = meta tidak diketahui; gagal-jujur tanpa crash.
1576
+ return []
1577
+ } finally {
1578
+ db.close()
1579
+ }
1580
+ }
1581
+
1582
+ // ── P14.0/P14.2 — pembaca READ-ONLY untuk inventaris & ekstraksi intent ──────
1583
+ //
1584
+ // Kontrak yang sama dengan `readSessionMetaRows` di atas: gerbang existsSync
1585
+ // (proyeksi tidak pernah meninggalkan berkas), gagal-jujur ([]) bila DB
1586
+ // rusak/tak terbaca, handle selalu ditutup. Pembacaan memakai jalur resolve
1587
+ // yang sama dengan penulisnya, jadi domain data tidak bisa berbeda dua arah.
1588
+
1589
+ export interface SessionInventoryRow {
1590
+ readonly id: string
1591
+ readonly created_at: number
1592
+ readonly updated_at: number
1593
+ readonly cwd: string | null
1594
+ readonly parent_session_id: string | null
1595
+ }
1596
+
1597
+ export function readSessionInventoryRows(cwd?: string): SessionInventoryRow[] {
1598
+ const p = dbPath(cwd)
1599
+ if (!existsSync(p)) return []
1600
+ const db = new Database(p)
1601
+ try {
1602
+ const rows = db
1603
+ .prepare(
1604
+ "SELECT id, created_at, COALESCE(updated_at, created_at) AS updated_at, cwd, parent_session_id FROM sessions",
1605
+ )
1606
+ .all() as {
1607
+ id: string
1608
+ created_at: number
1609
+ updated_at: number
1610
+ cwd?: string | null
1611
+ parent_session_id?: string | null
1612
+ }[]
1613
+ // NULL/undefined (baris legacy pra-binding) dinormalkan ke null supaya
1614
+ // pemanggil tidak pernah menghadapi undefined dari SQLite.
1615
+ return rows.map((r) => ({
1616
+ id: r.id,
1617
+ created_at: r.created_at,
1618
+ updated_at: r.updated_at,
1619
+ cwd: r.cwd ?? null,
1620
+ parent_session_id: r.parent_session_id ?? null,
1621
+ }))
1622
+ } catch {
1623
+ return []
1624
+ } finally {
1625
+ db.close()
1626
+ }
1627
+ }
1628
+
1629
+ export interface ReadOnlyEventLoad {
1630
+ events: DomainEvent[]
1631
+ /** Baris yang dibuang decoder — dilaporkan, tidak disembunyikan. */
1632
+ rejected: number
1633
+ }
1634
+
1635
+ /**
1636
+ * [P14.2] Seluruh event presentasi lintas sesi, read-only, SUDAH didekode.
1637
+ *
1638
+ * Dipakai ekstraksi intent; tidak pernah dipakai jalur tulis. `rejected`
1639
+ * wajib dilaporkan pemanggil supaya bukti yang tak terbaca tidak berubah
1640
+ * jadi "seolah tidak pernah ada".
1641
+ */
1642
+ export function readAllPresentationEventsReadOnly(cwd?: string): ReadOnlyEventLoad {
1643
+ const p = dbPath(cwd)
1644
+ if (!existsSync(p)) return { events: [], rejected: 0 }
1645
+ const db = new Database(p)
1646
+ try {
1647
+ const rows = db
1648
+ .prepare("SELECT payload FROM presentation_events ORDER BY session_id, event_seq")
1649
+ .all() as { payload: string }[]
1650
+ const events: DomainEvent[] = []
1651
+ let rejected = 0
1652
+ for (const row of rows) {
1653
+ const ev = decodePresentationEvent(row.payload)
1654
+ if (ev !== null) events.push(ev)
1655
+ else rejected++
1656
+ }
1657
+ return { events, rejected }
1658
+ } catch {
1659
+ return { events: [], rejected: 0 }
1660
+ } finally {
1661
+ db.close()
1662
+ }
1663
+ }
1664
+
1665
+ export interface RunInventoryRow {
1666
+ readonly run_id: string
1667
+ readonly session_id: string
1668
+ readonly status: string
1669
+ readonly started_at: number
1670
+ readonly ended_at: number | null
1671
+ readonly recovery_status: string | null
1672
+ }
1673
+
1674
+ export function readRunRowsReadOnly(cwd?: string): RunInventoryRow[] {
1675
+ const p = dbPath(cwd)
1676
+ if (!existsSync(p)) return []
1677
+ const db = new Database(p)
1678
+ try {
1679
+ return db
1680
+ .prepare("SELECT run_id, session_id, status, started_at, ended_at, recovery_status FROM runs")
1681
+ .all() as RunInventoryRow[]
1682
+ } catch {
1683
+ return []
1684
+ } finally {
1685
+ db.close()
1686
+ }
1687
+ }
1688
+
1689
+ // P2.1 — primitif peta alias identitas sesi (IO murni; keputusan di
1690
+ // `src/session/identity.ts`). Alias = input mentah eksak; canonical &
1691
+ // session row = bentuk kanonik (sudah sanitasi di pemanggil).
1692
+
1693
+ export interface SessionAliasRow {
1694
+ alias: string
1695
+ fs_key: string
1696
+ canonical: string
1697
+ reason: string
1698
+ created_at: number
1699
+ }
1700
+
1701
+ export function sessionRowExists(id: string, cwd?: string): boolean {
1702
+ const db = open(cwd)
1703
+ try {
1704
+ const row = db.prepare("SELECT 1 AS ok FROM sessions WHERE id = ?").get(id) as {
1705
+ ok: number
1706
+ } | null
1707
+ return row !== null
1708
+ } finally {
1709
+ db.close()
1710
+ }
1711
+ }
1712
+
1713
+ export function lookupSessionAlias(alias: string, cwd?: string): SessionAliasRow | null {
1714
+ const db = open(cwd)
1715
+ try {
1716
+ const row = db
1717
+ .prepare(
1718
+ "SELECT alias, fs_key, canonical, reason, created_at FROM session_aliases WHERE alias = ?",
1719
+ )
1720
+ .get(alias) as SessionAliasRow | null
1721
+ return row
1722
+ } finally {
1723
+ db.close()
1724
+ }
1725
+ }
1726
+
1727
+ export type RecordAliasOutcome =
1728
+ | { ok: true; created: boolean }
1729
+ // Alias eksak sudah menunjuk kanonik lain → target imutabel, tolak.
1730
+ | { ok: false; reason: "alias-conflict"; existing: string }
1731
+ // fs_key alias adalah baris sesi hidup yang berbeda → tabrakan kunci.
1732
+ | { ok: false; reason: "key-hijack"; existing: string }
1733
+ // Target kanonik tak ada baris sesinya → peta menggantung, tolak.
1734
+ | { ok: false; reason: "dangling-canonical" }
1735
+
1736
+ export function tryRecordSessionAlias(
1737
+ alias: string,
1738
+ fsKey: string,
1739
+ canonical: string,
1740
+ reason: string,
1741
+ cwd?: string,
1742
+ ): RecordAliasOutcome {
1743
+ if (alias === canonical) return { ok: true, created: false }
1744
+ const db = open(cwd)
1745
+ try {
1746
+ const existing = db
1747
+ .prepare("SELECT canonical FROM session_aliases WHERE alias = ?")
1748
+ .get(alias) as { canonical: string } | null
1749
+ if (existing) {
1750
+ if (existing.canonical === canonical) return { ok: true, created: false }
1751
+ return { ok: false, reason: "alias-conflict", existing: existing.canonical }
1752
+ }
1753
+ const rowHijack = db.prepare("SELECT 1 AS ok FROM sessions WHERE id = ?").get(fsKey) as {
1754
+ ok: number
1755
+ } | null
1756
+ if (rowHijack && fsKey !== canonical)
1757
+ return { ok: false, reason: "key-hijack", existing: fsKey }
1758
+ const target = db.prepare("SELECT 1 AS ok FROM sessions WHERE id = ?").get(canonical) as {
1759
+ ok: number
1760
+ } | null
1761
+ if (!target) return { ok: false, reason: "dangling-canonical" }
1762
+ const now = Date.now()
1763
+ db.prepare(
1764
+ "INSERT INTO session_aliases (alias, fs_key, canonical, reason, created_at) VALUES (?, ?, ?, ?, ?)",
1765
+ ).run(alias, fsKey, canonical, reason, now)
1766
+ return { ok: true, created: true }
1767
+ } finally {
1768
+ db.close()
1769
+ }
1770
+ }
1771
+
1772
+ // Kanonik lain yang berbagi fs_key: baris sesi ber-id == fsKey (bukan
1773
+ // resolved) + alias lain ber-fs_key sama yang menunjuk kanonik berbeda.
1774
+ export function findFsKeyConflicts(
1775
+ fsKey: string,
1776
+ resolvedCanonical: string,
1777
+ cwd?: string,
1778
+ ): { kind: "session-row" | "alias"; id: string; canonical: string }[] {
1779
+ const db = open(cwd)
1780
+ try {
1781
+ const out: { kind: "session-row" | "alias"; id: string; canonical: string }[] = []
1782
+ const row = db.prepare("SELECT id FROM sessions WHERE id = ?").get(fsKey) as {
1783
+ id: string
1784
+ } | null
1785
+ if (row && row.id !== resolvedCanonical) {
1786
+ out.push({ kind: "session-row", id: row.id, canonical: row.id })
1787
+ }
1788
+ const aliases = db
1789
+ .prepare("SELECT alias, canonical FROM session_aliases WHERE fs_key = ?")
1790
+ .all(fsKey) as { alias: string; canonical: string }[]
1791
+ for (const a of aliases) {
1792
+ if (a.canonical !== resolvedCanonical)
1793
+ out.push({ kind: "alias", id: a.alias, canonical: a.canonical })
1794
+ }
1795
+ return out
1796
+ } finally {
1797
+ db.close()
1798
+ }
1799
+ }
1800
+
1801
+ export function listSessionAliases(canonical: string, cwd?: string): SessionAliasRow[] {
1802
+ const db = open(cwd)
1803
+ try {
1804
+ return db
1805
+ .prepare(
1806
+ "SELECT alias, fs_key, canonical, reason, created_at FROM session_aliases WHERE canonical = ? ORDER BY created_at",
1807
+ )
1808
+ .all(canonical) as SessionAliasRow[]
1809
+ } finally {
1810
+ db.close()
1811
+ }
1812
+ }
1813
+
1814
+ // P2.2 — majukan generasi penulis tepat satu langkah, atomik terhadap
1815
+ // pengambil-alihan simultan. Kunci: PRIMARY KEY (session_id, prior_epoch) —
1816
+ // pecundang menabrak constraint dan MENGAMATI hasil pemenang (idempoten),
1817
+ // bukan menaikkan epoch lagi. Tak ada ketergantungan Date.now untuk
1818
+ // serialisasi; SQLite-lah arbiternya.
1819
+ export type TakeoverEpochOutcome =
1820
+ | { outcome: "advanced"; epoch: number }
1821
+ | { outcome: "already-applied"; epoch: number }
1822
+ | { outcome: "epoch-moved-unexpected"; epoch: number }
1823
+ | { outcome: "nothing-to-fence"; epoch: 0 }
1824
+
1825
+ export function takeoverSessionEpoch(
1826
+ sessionId: string,
1827
+ priorEpoch: number,
1828
+ reason: string,
1829
+ boot: string,
1830
+ cwd?: string,
1831
+ ): TakeoverEpochOutcome {
1832
+ const db = open(cwd)
1833
+ try {
1834
+ return db.transaction(() => {
1835
+ const row = db
1836
+ .prepare("SELECT writer_epoch AS epoch FROM sessions WHERE id = ?")
1837
+ .get(sessionId) as {
1838
+ epoch: number
1839
+ } | null
1840
+ if (row === null) return { outcome: "nothing-to-fence", epoch: 0 } as const
1841
+ if (row.epoch !== priorEpoch) {
1842
+ const rec = db
1843
+ .prepare(
1844
+ "SELECT new_epoch AS epoch FROM session_takeovers WHERE session_id = ? AND prior_epoch = ?",
1845
+ )
1846
+ .get(sessionId, priorEpoch) as { epoch: number } | null
1847
+ if (rec) return { outcome: "already-applied", epoch: rec.epoch } as const
1848
+ return { outcome: "epoch-moved-unexpected", epoch: row.epoch } as const
1849
+ }
1850
+ const ins = db
1851
+ .prepare(
1852
+ "INSERT OR IGNORE INTO session_takeovers (session_id, prior_epoch, new_epoch, reason, boot, created_at) VALUES (?, ?, ?, ?, ?, ?)",
1853
+ )
1854
+ .run(sessionId, priorEpoch, priorEpoch + 1, reason, boot, Date.now())
1855
+ if (ins.changes === 0) {
1856
+ const cur = db
1857
+ .prepare("SELECT writer_epoch AS epoch FROM sessions WHERE id = ?")
1858
+ .get(sessionId) as {
1859
+ epoch: number
1860
+ }
1861
+ return { outcome: "already-applied", epoch: cur.epoch } as const
1862
+ }
1863
+ const upd = db
1864
+ .prepare(
1865
+ "UPDATE sessions SET writer_epoch = ?, updated_at = ? WHERE id = ? AND writer_epoch = ?",
1866
+ )
1867
+ .run(priorEpoch + 1, Date.now(), sessionId, priorEpoch)
1868
+ if (upd.changes === 0) {
1869
+ const cur = db
1870
+ .prepare("SELECT writer_epoch AS epoch FROM sessions WHERE id = ?")
1871
+ .get(sessionId) as {
1872
+ epoch: number
1873
+ }
1874
+ return { outcome: "already-applied", epoch: cur.epoch } as const
1875
+ }
1876
+ return { outcome: "advanced", epoch: priorEpoch + 1 } as const
1877
+ })()
1878
+ } finally {
1879
+ db.close()
1880
+ }
1881
+ }
1882
+
1883
+ export function listSessionTakeovers(
1884
+ sessionId: string,
1885
+ cwd?: string,
1886
+ ): {
1887
+ prior_epoch: number
1888
+ new_epoch: number
1889
+ reason: string
1890
+ boot: string
1891
+ created_at: number
1892
+ }[] {
1893
+ const db = open(cwd)
1894
+ try {
1895
+ return db
1896
+ .prepare(
1897
+ "SELECT prior_epoch, new_epoch, reason, boot, created_at FROM session_takeovers WHERE session_id = ? ORDER BY prior_epoch",
1898
+ )
1899
+ .all(sessionId) as {
1900
+ prior_epoch: number
1901
+ new_epoch: number
1902
+ reason: string
1903
+ boot: string
1904
+ created_at: number
1905
+ }[]
1906
+ } finally {
1907
+ db.close()
1908
+ }
1909
+ }
1910
+
1911
+ // ── P2.5 — identitas event histori kanonik ─────────────────────────────
1912
+ // seq = ordering di dalam Thread; event_id = identitas stabil event.
1913
+ // Keduanya tak saling menurunkan. Kernel TAK PERNAH membawa event_id:
1914
+ // snapshot vendor membangun objek baru field-demi-field (snapshotMessage,
1915
+ // vendor/minicore/src/core/snapshot.ts:14-23) sehingga prop asing gugur di
1916
+ // setiap batas — adopsi POSISIONAL di saveSession adalah satu-satunya jalur
1917
+ // yang konsisten arsitektur. Jalur eksplisit per-event = appendHistoryEvent.
1918
+
1919
+ const ALLOCATED_EVENT_ID_RE =
1920
+ /^evt_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
1921
+ const DERIVED_EVENT_ID_RE = /^evt_migr_[0-9a-f]{32}$/
1922
+
1923
+ export function isHistoryEventId(value: unknown): value is string {
1924
+ return (
1925
+ typeof value === "string" &&
1926
+ (ALLOCATED_EVENT_ID_RE.test(value) || DERIVED_EVENT_ID_RE.test(value))
1927
+ )
1928
+ }
1929
+
1930
+ // SATU-SATUNYA allocator produksi: CSPRNG 122-bit, tanpa input (bukan dari
1931
+ // seq, bukan dari konten — tabrakan acak praktis mustahil; bila constraint
1932
+ // menabrak, save GAGAL loud, tak pernah merge diam-diam).
1933
+ export function allocateHistoryEventId(): string {
1934
+ return `evt_${randomUUID()}`
1935
+ }
1936
+
1937
+ // ID deterministik untuk baris legacy (NULL): stabil lintas run (sha256
1938
+ // session\0thread\0seq), idempoten by-construction, bentuk turunan.
1939
+ export function deriveLegacyHistoryEventId(
1940
+ sessionId: string,
1941
+ threadId: string,
1942
+ seq: number,
1943
+ ): string {
1944
+ const digest = createHash("sha256")
1945
+ .update(sessionId, "utf8")
1946
+ .update("\u0000", "utf8")
1947
+ .update(threadId, "utf8")
1948
+ .update("\u0000", "utf8")
1949
+ .update(String(seq), "utf8")
1950
+ .digest("hex")
1951
+ .slice(0, 32)
1952
+ return `evt_migr_${digest}`
1953
+ }
1954
+
1955
+ export class EventIdConflictError extends Error {
1956
+ readonly code = "REFUSED_EVENT_ID_CONFLICT"
1957
+ readonly sessionId: string
1958
+ readonly threadId: string
1959
+ readonly eventId: string
1960
+ constructor(sessionId: string, threadId: string, eventId: string) {
1961
+ super(
1962
+ `[history] REFUSED_EVENT_ID_CONFLICT ${sessionId}/${threadId} event ${eventId} — same id, different event; original is authoritative`,
1963
+ )
1964
+ this.name = "EventIdConflictError"
1965
+ this.sessionId = sessionId
1966
+ this.threadId = threadId
1967
+ this.eventId = eventId
1968
+ }
1969
+ }
1970
+
1971
+ export class EventIdInvalidError extends Error {
1972
+ readonly code = "REFUSED_EVENT_ID_INVALID"
1973
+ constructor(value: string) {
1974
+ super(
1975
+ `[history] REFUSED_EVENT_ID_INVALID "${value}" — not an allocated or derived history event id`,
1976
+ )
1977
+ this.name = "EventIdInvalidError"
1978
+ }
1979
+ }
1980
+ // ── P2.4 — primitif Thread ──────────────────────────────────────────────
1981
+ // Identitas komposit (session_id, thread_id): 'th_default' bermakna per
1982
+ // sesi. head_seq = MAX(seq) histori thread (-1 = kosong): cache, BUKAN
1983
+ // sumber kebenaran. Tak ada traversal/merge di fase ini (P3+).
1984
+
1985
+ export const DEFAULT_THREAD_ID = "th_default"
1986
+
1987
+ export interface ThreadRow {
1988
+ session_id: string
1989
+ thread_id: string
1990
+ parent_thread_id: string | null
1991
+ fork_event_seq: number | null
1992
+ head_seq: number
1993
+ status: string
1994
+ read_only: number
1995
+ created_at: number
1996
+ }
1997
+
1998
+ export class ThreadArchivedError extends Error {
1999
+ readonly code = "THREAD_ARCHIVED"
2000
+ constructor(sessionId: string, threadId: string) {
2001
+ super(`[thread] ${sessionId}/${threadId} is archived — history mutation refused`)
2002
+ this.name = "ThreadArchivedError"
2003
+ }
2004
+ }
2005
+
2006
+ export class ThreadParentError extends Error {
2007
+ readonly code: "THREAD_PARENT_INVALID" | "THREAD_READONLY_PARENT" | "THREAD_FORK_SEQ_INVALID"
2008
+ constructor(code: ThreadParentError["code"], sessionId: string, detail: string) {
2009
+ super(`[thread] ${sessionId}: ${detail}`)
2010
+ this.name = "ThreadParentError"
2011
+ this.code = code
2012
+ }
2013
+ }
2014
+
2015
+ function rowToThread(row: ThreadRow): ThreadRow {
2016
+ return { ...row }
2017
+ }
2018
+
2019
+ export function getThread(sessionId: string, threadId: string, cwd?: string): ThreadRow | null {
2020
+ const db = open(cwd)
2021
+ try {
2022
+ const row = db
2023
+ .prepare(
2024
+ "SELECT session_id, thread_id, parent_thread_id, fork_event_seq, head_seq, status, read_only, created_at FROM threads WHERE session_id = ? AND thread_id = ?",
2025
+ )
2026
+ .get(sessionId, threadId) as ThreadRow | null
2027
+ return row ? rowToThread(row) : null
2028
+ } finally {
2029
+ db.close()
2030
+ }
2031
+ }
2032
+
2033
+ // Resolve thread default: kolom sessions.default_thread_id, fallback ke
2034
+ // konvensi. Murni baca (tanpa materialisasi); null = sesi/threadless.
2035
+ export function getDefaultThread(sessionId: string, cwd?: string): ThreadRow | null {
2036
+ const db = open(cwd)
2037
+ try {
2038
+ const sess = db
2039
+ .prepare("SELECT default_thread_id FROM sessions WHERE id = ?")
2040
+ .get(sessionId) as {
2041
+ default_thread_id: string | null
2042
+ } | null
2043
+ const tid = sess?.default_thread_id ?? DEFAULT_THREAD_ID
2044
+ const row = db
2045
+ .prepare(
2046
+ "SELECT session_id, thread_id, parent_thread_id, fork_event_seq, head_seq, status, read_only, created_at FROM threads WHERE session_id = ? AND thread_id = ?",
2047
+ )
2048
+ .get(sessionId, tid) as ThreadRow | null
2049
+ return row ? rowToThread(row) : null
2050
+ } finally {
2051
+ db.close()
2052
+ }
2053
+ }
2054
+
2055
+ function recomputeThreadHeadInTxn(db: Database, sessionId: string, threadId: string): number {
2056
+ const maxRow = db
2057
+ .prepare("SELECT MAX(seq) AS m FROM messages WHERE session_id = ? AND thread_id = ?")
2058
+ .get(sessionId, threadId) as { m: number | null } | null
2059
+ const head = maxRow?.m ?? -1
2060
+ db.prepare("UPDATE threads SET head_seq = ? WHERE session_id = ? AND thread_id = ?").run(
2061
+ head,
2062
+ sessionId,
2063
+ threadId,
2064
+ )
2065
+ return head
2066
+ }
2067
+
2068
+ // Inti ensure (dipakai ensureDefaultThread + saveSession dalam txn yang
2069
+ // sama — SATU-SATUNYA tempat baris Thread default dimaterialisasi).
2070
+ function ensureDefaultThreadInTxn(db: Database, sessionId: string, now: number): ThreadRow {
2071
+ // P2.6: pasangan (sesi, thread) dijamin atomik — baris sesi dibuat bila
2072
+ // absen (turn-start pada sesi fresh; saveSession menimpanya dengan
2073
+ // cwd/system lengkap kemudian). Epoch fresh = 0, konsisten dengan upsert.
2074
+ db.prepare(
2075
+ "INSERT INTO sessions (id, created_at, updated_at, cwd, system, writer_epoch) VALUES (?, ?, ?, ?, ?, COALESCE((SELECT writer_epoch FROM sessions WHERE id = ?), 0)) ON CONFLICT(id) DO NOTHING",
2076
+ ).run(sessionId, now, now, "", "", sessionId)
2077
+ // INSERT OR IGNORE + baca ulang: dua ensure konkuren menghasilkan tepat
2078
+ // satu baris (pecundang mengamati, bukan duplikat). Tanpa sleep/retry.
2079
+ db.prepare(
2080
+ "INSERT OR IGNORE INTO threads (session_id, thread_id, parent_thread_id, fork_event_seq, head_seq, status, read_only, created_at) VALUES (?, ?, NULL, NULL, -1, 'active', 0, ?)",
2081
+ ).run(sessionId, DEFAULT_THREAD_ID, now)
2082
+ // Backfill aditif: HANYA thread_id (konten/seq/timestamp tak tersentuh).
2083
+ db.prepare("UPDATE messages SET thread_id = ? WHERE session_id = ? AND thread_id IS NULL").run(
2084
+ DEFAULT_THREAD_ID,
2085
+ sessionId,
2086
+ )
2087
+ db.prepare("UPDATE sessions SET default_thread_id = ? WHERE id = ?").run(
2088
+ DEFAULT_THREAD_ID,
2089
+ sessionId,
2090
+ )
2091
+ recomputeThreadHeadInTxn(db, sessionId, DEFAULT_THREAD_ID)
2092
+ const row = db
2093
+ .prepare(
2094
+ "SELECT session_id, thread_id, parent_thread_id, fork_event_seq, head_seq, status, read_only, created_at FROM threads WHERE session_id = ? AND thread_id = ?",
2095
+ )
2096
+ .get(sessionId, DEFAULT_THREAD_ID) as ThreadRow
2097
+ return rowToThread(row)
2098
+ }
2099
+
2100
+ // ── P2.9 — Sub-Agent runtime (Model C) ───────────────────────────────────────
2101
+ //
2102
+ // Sub-Agent = entitas eksekusi TERSENDIRI yang direalisasi sebagai Session +
2103
+ // Thread + Run kanonik sendiri, dengan lineage durable ke parent Session DAN
2104
+ // parent Run. Alasannya BUKAN aesthetics tapi constraint repo:
2105
+ //
2106
+ // udx_runs_single_running ON runs(session_id) WHERE status='RUNNING'
2107
+ //
2108
+ // ⇒ anak-anak TIDAK bisa RUNNING bersamaan dalam satu Session, sedangkan
2109
+ // delegate_task menjalankan anak lewat Pool(SUB_AGENT_POOL_SIZE) (concurrency).
2110
+ // Satu-satunya topologi yang memenuhi keduanya: satu child = satu Session.
2111
+ //
2112
+ // CATATAN IDENTITAS (P2.9 §2): id anak P1 lawas `sub_<8hex>` hanya 32-bit dan
2113
+ // TERLALU LEMAH untuk jadi identitas durable kanonik. Alokator di bawah
2114
+ // memberi 128-bit dengan prefiks sama (kompatibilitas jurnal/presentasi).
2115
+ // `executionId` kind "child" (P1) TETAP identitas runtime — tidak ditukar
2116
+ // dengan id sesi kanonik ini; keduanya hidup berdampingan.
2117
+
2118
+ export function allocateChildSessionId(): string {
2119
+ return `sub_${randomUUID().replace(/-/g, "")}`
2120
+ }
2121
+
2122
+ export interface ChildSessionLink {
2123
+ parent_session_id: string | null
2124
+ parent_run_id: string | null
2125
+ }
2126
+
2127
+ export interface ChildSessionRecord {
2128
+ sessionId: string
2129
+ parentSessionId: string
2130
+ parentRunId: string | null
2131
+ threadId: string
2132
+ runId: string
2133
+ }
2134
+
2135
+ /**
2136
+ * Creates the canonical Sub-Agent namespace: sessions row + default Thread +
2137
+ * a CREATED Run, ALL in one transaction. Durable causality: nothing about the
2138
+ * child may become durable before its Session row exists (this is what closes
2139
+ * the phantom-namespace defect where child presentation_events were purged).
2140
+ *
2141
+ * NOT started here — the caller transitions to RUNNING (P2.6 state machine)
2142
+ * after holding the child writer admission, so the RUNNING record and the epoch
2143
+ * that authorises writes appear in the right order.
2144
+ */
2145
+ export function createChildSession(opts: {
2146
+ parentSessionId: string
2147
+ parentRunId?: string | null
2148
+ cwd?: string
2149
+ childSessionId?: string
2150
+ expectedParentEpoch?: number
2151
+ system?: string
2152
+ }): ChildSessionRecord {
2153
+ const cwd = opts.cwd
2154
+ const childSessionId = opts.childSessionId ?? allocateChildSessionId()
2155
+ if (!childSessionId.startsWith("sub_")) {
2156
+ throw new Error(`invalid child session id: ${childSessionId}`)
2157
+ }
2158
+ const db = open(cwd)
2159
+ const now = Date.now()
2160
+ try {
2161
+ // withBusyRetrySync: anak-anak paralel (Pool SUB_AGENT_POOL_SIZE) menulis
2162
+ // sessions.db bersamaan → SQLITE_BUSY yang wajar, BUKAN kegagalan durable.
2163
+ // Retry sinkron yang sudah ada (pola open() P1).
2164
+ const record = withBusyRetrySync<ChildSessionRecord>(() =>
2165
+ db.transaction(() => {
2166
+ if (!sessionRowExistsInTxn(db, opts.parentSessionId)) {
2167
+ // Parent belum punya baris (mis. tool dipanggil sebelum persist parent
2168
+ // selesai). Pola yang SAMA dengan ensureDefaultThreadInTxn P2.4 /
2169
+ // saveSession: materialisasi baris sesi, bukan menolak — lineage child
2170
+ // tetap menunjuk baris `sessions` kanonik. saveSession parent kemudian
2171
+ // menimpanya dengan cwd/system lengkap.
2172
+ db.prepare(
2173
+ "INSERT INTO sessions (id, created_at, updated_at, cwd, system, writer_epoch) VALUES (?, ?, ?, '', ?, 0) ON CONFLICT(id) DO NOTHING",
2174
+ ).run(opts.parentSessionId, now, now, opts.system ?? "")
2175
+ }
2176
+ if (opts.expectedParentEpoch !== undefined) {
2177
+ assertWriterEpochInTxn(db, opts.parentSessionId, opts.expectedParentEpoch)
2178
+ }
2179
+ // Idempotent by id: re-creating an existing child returns its record.
2180
+ const existing = db
2181
+ .prepare("SELECT parent_session_id, parent_run_id FROM sessions WHERE id = ?")
2182
+ .get(childSessionId) as ChildSessionLink | null
2183
+ if (existing) {
2184
+ if (existing.parent_session_id !== opts.parentSessionId) {
2185
+ throw new Error(
2186
+ `child session ${childSessionId} already owned by ${String(existing.parent_session_id)}`,
2187
+ )
2188
+ }
2189
+ const thread = ensureDefaultThreadInTxn(db, childSessionId, now)
2190
+ const run = db
2191
+ .prepare(
2192
+ "SELECT run_id, thread_id FROM runs WHERE session_id = ? ORDER BY created_at LIMIT 1",
2193
+ )
2194
+ .get(childSessionId) as { run_id: string; thread_id: string } | undefined
2195
+ if (run) {
2196
+ return {
2197
+ sessionId: childSessionId,
2198
+ parentSessionId: opts.parentSessionId,
2199
+ parentRunId: existing.parent_run_id,
2200
+ threadId: thread.thread_id,
2201
+ runId: run.run_id,
2202
+ }
2203
+ }
2204
+ }
2205
+ db.prepare(
2206
+ "INSERT INTO sessions (id, created_at, updated_at, cwd, system, writer_epoch, parent_session_id, parent_run_id) VALUES (?, ?, ?, '', ?, 0, ?, ?) ON CONFLICT(id) DO UPDATE SET parent_session_id = excluded.parent_session_id, parent_run_id = excluded.parent_run_id",
2207
+ ).run(
2208
+ childSessionId,
2209
+ now,
2210
+ now,
2211
+ opts.system ?? "",
2212
+ opts.parentSessionId,
2213
+ opts.parentRunId ?? null,
2214
+ )
2215
+ const thread = ensureDefaultThreadInTxn(db, childSessionId, now)
2216
+ // Durable execution record = P2 Run (P2.6 state machine, no new FSM).
2217
+ const runId = allocateRunId()
2218
+ const epochRow = db
2219
+ .prepare("SELECT writer_epoch AS epoch FROM sessions WHERE id = ?")
2220
+ .get(childSessionId) as { epoch: number }
2221
+ db.prepare(
2222
+ "INSERT INTO runs (run_id, session_id, thread_id, status, started_at, ended_at, last_persisted_seq, pending_tool_ids, recovery_status, takeover_epoch, created_at) VALUES (?, ?, ?, 'CREATED', ?, NULL, 0, '[]', 'NONE', ?, ?)",
2223
+ ).run(runId, childSessionId, thread.thread_id, now, epochRow.epoch, now)
2224
+ return {
2225
+ sessionId: childSessionId,
2226
+ parentSessionId: opts.parentSessionId,
2227
+ parentRunId: opts.parentRunId ?? null,
2228
+ threadId: thread.thread_id,
2229
+ runId,
2230
+ }
2231
+ })(),
2232
+ )
2233
+ if (record === null) throw new Error(`child session busy: ${childSessionId}`)
2234
+ return record
2235
+ } finally {
2236
+ db.close()
2237
+ }
2238
+ }
2239
+
2240
+ /** Durable lineage of a Session (NULL fields for a root/parent Session). */
2241
+ export function getChildSessionLink(sessionId: string, cwd?: string): ChildSessionLink | null {
2242
+ const db = open(cwd)
2243
+ try {
2244
+ return (
2245
+ (db
2246
+ .prepare("SELECT parent_session_id, parent_run_id FROM sessions WHERE id = ?")
2247
+ .get(sessionId) as ChildSessionLink | null) ?? null
2248
+ )
2249
+ } finally {
2250
+ db.close()
2251
+ }
2252
+ }
2253
+
2254
+ /** Child Sessions of a parent, newest first. */
2255
+ export function listChildSessions(parentSessionId: string, cwd?: string): string[] {
2256
+ const db = open(cwd)
2257
+ try {
2258
+ const rows = db
2259
+ .prepare("SELECT id FROM sessions WHERE parent_session_id = ? ORDER BY created_at DESC")
2260
+ .all(parentSessionId) as { id: string }[]
2261
+ return rows.map((r) => r.id)
2262
+ } finally {
2263
+ db.close()
2264
+ }
2265
+ }
2266
+
2267
+ /** True when a Session has at least one child Session (delete-safety). */
2268
+ export function hasChildSessions(sessionId: string, cwd?: string): boolean {
2269
+ const db = open(cwd)
2270
+ try {
2271
+ const row = db
2272
+ .prepare("SELECT 1 AS ok FROM sessions WHERE parent_session_id = ? LIMIT 1")
2273
+ .get(sessionId) as { ok: number } | null
2274
+ return row !== null
2275
+ } finally {
2276
+ db.close()
2277
+ }
2278
+ }
2279
+
2280
+ /**
2281
+ * Orphan sweep: RUNNING child Runs whose parent is no longer live become
2282
+ * INTERRUPTED + recovery UNKNOWN (P2.6 tombstone semantics — a death is never
2283
+ * observed, so nothing may be inferred as COMPLETED). Idempotent.
2284
+ */
2285
+ export function tombstoneOrphanChildRuns(
2286
+ parentSessionId: string,
2287
+ cwd?: string,
2288
+ opts?: { expectedEpoch?: number },
2289
+ ): string[] {
2290
+ const db = open(cwd)
2291
+ try {
2292
+ return db.transaction(() => {
2293
+ if (opts?.expectedEpoch !== undefined) {
2294
+ assertWriterEpochInTxn(db, parentSessionId, opts.expectedEpoch)
2295
+ }
2296
+ // CREATED ikut serta: Run anak yang masih CREATED saat parent jatuh =
2297
+ // sisa dari jendela sinkron createChildSession→RUNNING yang tak pernah
2298
+ // selesai. Meninggalkannya berarti ada eksekusi durable yang tak
2299
+ // terlacak; menombaknya (INTERRUPTED/UNKNOWN) jujur — ia memang tak pernah
2300
+ // berjalan. RUNNING tetap inti aturannya; CREATED hanya memperluas
2301
+ // penutupan, tak pernah melonggarkan.
2302
+ const rows = db
2303
+ .prepare(
2304
+ "SELECT r.run_id FROM runs r JOIN sessions s ON s.id = r.session_id WHERE s.parent_session_id = ? AND r.status IN ('RUNNING', 'CREATED')",
2305
+ )
2306
+ .all(parentSessionId) as { run_id: string }[]
2307
+ const out: string[] = []
2308
+ for (const row of rows) {
2309
+ // P9.3.1 (D3): laporkan hanya baris yang transisi ini benar-benar
2310
+ // pindahkan. Pemenang race (sudah terminal oleh completeRun/failRun)
2311
+ // cocok 0 baris di WHERE status IN (...) — keamanannya tetap
2312
+ // first-terminal-wins, tapi tak dihitung sebagai tombstone-an kita.
2313
+ const moved = db
2314
+ .prepare(
2315
+ "UPDATE runs SET status = 'INTERRUPTED', recovery_status = 'UNKNOWN' WHERE run_id = ? AND status IN ('RUNNING', 'CREATED')",
2316
+ )
2317
+ .run(row.run_id).changes
2318
+ if (moved > 0) out.push(row.run_id)
2319
+ }
2320
+ return out
2321
+ })()
2322
+ } finally {
2323
+ db.close()
2324
+ }
2325
+ }
2326
+
2327
+ /**
2328
+ * Parent reached a terminal state ⇒ its children may not stay RUNNING.
2329
+ * Same rule as the orphan sweep (INTERRUPTED + UNKNOWN, ended_at NULL): we
2330
+ * cannot claim they finished, and must never leave an untracked durable
2331
+ * execution behind.
2332
+ */
2333
+ export function terminalizeChildRuns(
2334
+ parentSessionId: string,
2335
+ cwd?: string,
2336
+ opts?: { expectedEpoch?: number },
2337
+ ): string[] {
2338
+ return tombstoneOrphanChildRuns(parentSessionId, cwd, opts)
2339
+ }
2340
+
2341
+ // Materialisasi default Thread untuk sesi existing (resume/migrasi).
2342
+ // Fenced bila expectedEpoch disediakan (mutasi sesi). Idempoten.
2343
+ export function ensureDefaultThread(
2344
+ sessionId: string,
2345
+ cwd?: string,
2346
+ opts?: { expectedEpoch?: number },
2347
+ ): ThreadRow {
2348
+ const db = open(cwd)
2349
+ try {
2350
+ return db.transaction(() => {
2351
+ if (opts?.expectedEpoch !== undefined)
2352
+ assertWriterEpochInTxn(db, sessionId, opts.expectedEpoch)
2353
+ return ensureDefaultThreadInTxn(db, sessionId, Date.now())
2354
+ })()
2355
+ } finally {
2356
+ db.close()
2357
+ }
2358
+ }
2359
+
2360
+ // Primitif create untuk P2 branching/sub-agen mendatang. Tanpa CLI/UX.
2361
+ // Fenced, tanpa histori awal, tanpa traversal, tanpa copy.
2362
+ export function createThread(
2363
+ sessionId: string,
2364
+ cwd?: string,
2365
+ opts?: {
2366
+ threadId?: string
2367
+ parentThreadId?: string
2368
+ forkEventSeq?: number
2369
+ expectedEpoch?: number
2370
+ },
2371
+ ): ThreadRow {
2372
+ const db = open(cwd)
2373
+ try {
2374
+ return db.transaction(() => {
2375
+ if (opts?.expectedEpoch !== undefined)
2376
+ assertWriterEpochInTxn(db, sessionId, opts.expectedEpoch)
2377
+ const hasSession = db.prepare("SELECT 1 AS ok FROM sessions WHERE id = ?").get(sessionId) as {
2378
+ ok: number
2379
+ } | null
2380
+ if (!hasSession) throw new Error(`session not found: ${sessionId}`)
2381
+ if (opts?.parentThreadId !== undefined) {
2382
+ const parent = db
2383
+ .prepare(
2384
+ "SELECT thread_id, fork_event_seq, head_seq, status, read_only FROM threads WHERE session_id = ? AND thread_id = ?",
2385
+ )
2386
+ .get(sessionId, opts.parentThreadId) as {
2387
+ thread_id: string
2388
+ fork_event_seq: number | null
2389
+ head_seq: number
2390
+ status: string
2391
+ read_only: number
2392
+ } | null
2393
+ if (!parent) {
2394
+ throw new ThreadParentError(
2395
+ "THREAD_PARENT_INVALID",
2396
+ sessionId,
2397
+ `parent thread not found: ${opts.parentThreadId}`,
2398
+ )
2399
+ }
2400
+ if (parent.read_only === 1) {
2401
+ throw new ThreadParentError(
2402
+ "THREAD_READONLY_PARENT",
2403
+ sessionId,
2404
+ `migrated lineage cannot fork: ${opts.parentThreadId}`,
2405
+ )
2406
+ }
2407
+ if (
2408
+ opts.forkEventSeq !== undefined &&
2409
+ (!Number.isInteger(opts.forkEventSeq) ||
2410
+ opts.forkEventSeq < 0 ||
2411
+ opts.forkEventSeq > parent.head_seq)
2412
+ ) {
2413
+ throw new ThreadParentError(
2414
+ "THREAD_FORK_SEQ_INVALID",
2415
+ sessionId,
2416
+ `fork seq ${opts.forkEventSeq} outside parent head ${parent.head_seq}`,
2417
+ )
2418
+ }
2419
+ }
2420
+ const now = Date.now()
2421
+ for (let attempt = 0; attempt < 3; attempt++) {
2422
+ const tid =
2423
+ opts?.threadId ??
2424
+ `th_${Math.floor(Math.random() * 0xffffffff)
2425
+ .toString(16)
2426
+ .padStart(8, "0")}`
2427
+ if (opts?.threadId && attempt > 0) {
2428
+ throw new Error(`thread already exists: ${sessionId}/${opts.threadId}`)
2429
+ }
2430
+ const ins = db
2431
+ .prepare(
2432
+ "INSERT OR IGNORE INTO threads (session_id, thread_id, parent_thread_id, fork_event_seq, head_seq, status, read_only, created_at) VALUES (?, ?, ?, ?, -1, 'active', 0, ?)",
2433
+ )
2434
+ .run(sessionId, tid, opts?.parentThreadId ?? null, opts?.forkEventSeq ?? null, now)
2435
+ if (ins.changes === 1) {
2436
+ return rowToThread({
2437
+ session_id: sessionId,
2438
+ thread_id: tid,
2439
+ parent_thread_id: opts?.parentThreadId ?? null,
2440
+ fork_event_seq: opts?.forkEventSeq ?? null,
2441
+ head_seq: -1,
2442
+ status: "active",
2443
+ read_only: 0,
2444
+ created_at: now,
2445
+ })
2446
+ }
2447
+ }
2448
+ throw new Error(`thread id allocation failed: ${sessionId}`)
2449
+ })()
2450
+ } finally {
2451
+ db.close()
2452
+ }
2453
+ }
2454
+
2455
+ // Arsip: tetap terbaca, menolak tulis baru. Idempoten.
2456
+ export function archiveThread(
2457
+ sessionId: string,
2458
+ threadId: string,
2459
+ cwd?: string,
2460
+ opts?: { expectedEpoch?: number },
2461
+ ): ThreadRow {
2462
+ const db = open(cwd)
2463
+ try {
2464
+ return db.transaction(() => {
2465
+ if (opts?.expectedEpoch !== undefined)
2466
+ assertWriterEpochInTxn(db, sessionId, opts.expectedEpoch)
2467
+ const row = db
2468
+ .prepare(
2469
+ "SELECT session_id, thread_id, parent_thread_id, fork_event_seq, head_seq, status, read_only, created_at FROM threads WHERE session_id = ? AND thread_id = ?",
2470
+ )
2471
+ .get(sessionId, threadId) as ThreadRow | null
2472
+ if (!row) throw new Error(`thread not found: ${sessionId}/${threadId}`)
2473
+ db.prepare(
2474
+ "UPDATE threads SET status = 'archived' WHERE session_id = ? AND thread_id = ?",
2475
+ ).run(sessionId, threadId)
2476
+ return rowToThread({ ...row, status: "archived" })
2477
+ })()
2478
+ } finally {
2479
+ db.close()
2480
+ }
2481
+ }
2482
+
2483
+ // ── P2.5 — backfill + append eksplisit ────────────────────────────────────
2484
+ // Backfill: baris legacy (event_id NULL) mendapat id TURUNAN deterministik
2485
+ // + migrated=1, TANPA menyentuh konten/seq/thread/timestamp. Idempoten
2486
+ // (non-NULL dilewati; derivasi sama → hasil sama). Fenced bila diminta.
2487
+ // Append eksplisit: SATU-SATUNYA jalur per-event (P2.6+ akan memakainya);
2488
+ // saveSession tetap satu-satunya penulis produksi volume saat ini.
2489
+
2490
+ export function backfillHistoryEventIds(
2491
+ sessionId: string,
2492
+ cwd?: string,
2493
+ opts?: { expectedEpoch?: number },
2494
+ ): number {
2495
+ const db = open(cwd)
2496
+ try {
2497
+ return db.transaction(() => {
2498
+ if (opts?.expectedEpoch !== undefined)
2499
+ assertWriterEpochInTxn(db, sessionId, opts.expectedEpoch)
2500
+ const rows = db
2501
+ .prepare(
2502
+ "SELECT seq, thread_id FROM messages WHERE session_id = ? AND event_id IS NULL ORDER BY seq",
2503
+ )
2504
+ .all(sessionId) as { seq: number; thread_id: string | null }[]
2505
+ let backfilled = 0
2506
+ const upd = db.prepare(
2507
+ "UPDATE messages SET event_id = ?, migrated = 1 WHERE session_id = ? AND seq = ? AND event_id IS NULL",
2508
+ )
2509
+ for (const r of rows) {
2510
+ // Thread derivasi: kolom thread milik ensure (P2.4); derivasi memakai
2511
+ // nilai resolved agar stabil baik sebelum maupun sesudah backfill-nya.
2512
+ const tid = r.thread_id ?? DEFAULT_THREAD_ID
2513
+ const derived = deriveLegacyHistoryEventId(sessionId, tid, r.seq)
2514
+ backfilled += upd.run(derived, sessionId, r.seq).changes
2515
+ }
2516
+ return backfilled
2517
+ })()
2518
+ } finally {
2519
+ db.close()
2520
+ }
2521
+ }
2522
+
2523
+ export interface HistoryEventInput {
2524
+ role: string
2525
+ content: unknown
2526
+ toolCalls?: unknown
2527
+ toolCallId?: string
2528
+ name?: string
2529
+ reasoning?: string
2530
+ isError?: boolean
2531
+ }
2532
+
2533
+ export type AppendHistoryEventOutcome =
2534
+ | { outcome: "appended"; seq: number; eventId: string }
2535
+ | { outcome: "duplicate"; seq: number; eventId: string }
2536
+
2537
+ // Jalur append per-event kanonik: alokasi (atau id eksplisit valid) +
2538
+ // append + head, SATU txn berpagar. Duplikat identik = idempoten tanpa seq
2539
+ // baru; payload beda = REFUSED_EVENT_ID_CONFLICT (asli otoritatif).
2540
+ export function appendHistoryEvent(
2541
+ sessionId: string,
2542
+ threadId: string,
2543
+ event: HistoryEventInput,
2544
+ cwd?: string,
2545
+ opts?: { eventId?: string; runId?: string; expectedEpoch?: number },
2546
+ ): AppendHistoryEventOutcome {
2547
+ const db = open(cwd)
2548
+ try {
2549
+ return db.transaction(() => {
2550
+ if (opts?.expectedEpoch !== undefined)
2551
+ assertWriterEpochInTxn(db, sessionId, opts.expectedEpoch)
2552
+ const thread = db
2553
+ .prepare("SELECT status FROM threads WHERE session_id = ? AND thread_id = ?")
2554
+ .get(sessionId, threadId) as { status: string } | null
2555
+ if (!thread) throw new Error(`thread not found: ${sessionId}/${threadId}`)
2556
+ if (thread.status === "archived") throw new ThreadArchivedError(sessionId, threadId)
2557
+ let eid: string
2558
+ if (opts?.eventId !== undefined) {
2559
+ if (!isHistoryEventId(opts.eventId)) throw new EventIdInvalidError(opts.eventId)
2560
+ eid = opts.eventId
2561
+ } else {
2562
+ eid = allocateHistoryEventId()
2563
+ }
2564
+ // [Audit #2 B.2] Satu sumber tuple dedup F-05 — pakai helper yang sama
2565
+ // dengan `saveSession` agar logika normalisasi tak menyimpang di dua tempat.
2566
+ const want = normalizeMessageTupleForDedup(event)
2567
+ const existing = db
2568
+ .prepare(
2569
+ "SELECT seq, role, content, toolCalls, toolCallId, name, reasoning, is_error FROM messages WHERE session_id = ? AND thread_id = ? AND event_id = ?",
2570
+ )
2571
+ .get(sessionId, threadId, eid) as {
2572
+ seq: number
2573
+ role: string
2574
+ content: string
2575
+ toolCalls: string
2576
+ toolCallId: string | null
2577
+ name: string | null
2578
+ reasoning: string | null
2579
+ is_error: number | null
2580
+ } | null
2581
+ if (existing) {
2582
+ const same =
2583
+ existing.role === want[0] &&
2584
+ existing.content === want[1] &&
2585
+ existing.toolCalls === want[2] &&
2586
+ (existing.toolCallId ?? null) === want[3] &&
2587
+ (existing.name ?? null) === want[4] &&
2588
+ (existing.reasoning ?? null) === want[5] &&
2589
+ (existing.is_error ?? 0) === want[6]
2590
+ if (!same) throw new EventIdConflictError(sessionId, threadId, eid)
2591
+ return { outcome: "duplicate", seq: existing.seq, eventId: eid } as const
2592
+ }
2593
+ const maxRow = db
2594
+ .prepare("SELECT MAX(seq) AS m FROM messages WHERE session_id = ? AND thread_id = ?")
2595
+ .get(sessionId, threadId) as { m: number | null } | null
2596
+ const seq = (maxRow?.m ?? -1) + 1
2597
+ const now = Date.now()
2598
+ db.prepare(
2599
+ "INSERT INTO messages (session_id, thread_id, seq, role, content, toolCalls, toolCallId, name, reasoning, is_error, ts, event_id, run_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
2600
+ ).run(
2601
+ sessionId,
2602
+ threadId,
2603
+ seq,
2604
+ want[0],
2605
+ want[1],
2606
+ want[2],
2607
+ want[3],
2608
+ want[4],
2609
+ want[5],
2610
+ want[6],
2611
+ now,
2612
+ eid,
2613
+ opts?.runId ?? null,
2614
+ )
2615
+ recomputeThreadHeadInTxn(db, sessionId, threadId)
2616
+ // P2.6: event + kursor dalam SATU txn yang sama. Jalur append per-event
2617
+ // tak boleh jadi celah "event durable tapi kursor basi".
2618
+ if (opts?.runId !== undefined) {
2619
+ // Run terminal = kursor beku: event tetap durable (histori tak
2620
+ // dibuang diam-diam), tapi posisi run tak lagi bergerak.
2621
+ const st = db.prepare("SELECT status FROM runs WHERE run_id = ?").get(opts.runId) as {
2622
+ status: string
2623
+ } | null
2624
+ if (!st) throw new Error(`run not found: ${opts.runId}`)
2625
+ if (!RUN_TERMINAL.has(st.status)) advanceRunCursorInTxn(db, opts.runId, seq, sessionId)
2626
+ }
2627
+ return { outcome: "appended", seq, eventId: eid } as const
2628
+ })()
2629
+ } finally {
2630
+ db.close()
2631
+ }
2632
+ }
2633
+
2634
+ // ── P2.6 — Run durable + kursor ───────────────────────────────────────────
2635
+ // Run = SATU instans eksekusi pada (session_id, thread_id). BUKAN histori,
2636
+ // BUKAN thread, BUKAN loop. Status minimal: CREATED→RUNNING→terminal
2637
+ // (COMPLETED|INTERRUPTED|FAILED). Kursor = last_persisted_seq (posisi
2638
+ // persistensi, bukan token/usaha). ≤1 RUNNING per SESSION ditegakkan
2639
+ // partial-unique-index (ras-aman, tanpa TOCTOU). Semua mutasi berpagar epoch.
2640
+
2641
+ export type RunStatus = "CREATED" | "RUNNING" | "COMPLETED" | "INTERRUPTED" | "FAILED"
2642
+
2643
+ const RUN_TERMINAL: ReadonlySet<string> = new Set(["COMPLETED", "INTERRUPTED", "FAILED"])
2644
+
2645
+ export interface RunRow {
2646
+ run_id: string
2647
+ session_id: string
2648
+ thread_id: string
2649
+ status: RunStatus
2650
+ started_at: number
2651
+ ended_at: number | null
2652
+ last_persisted_seq: number
2653
+ pending_tool_ids: string
2654
+ recovery_status: string | null
2655
+ takeover_epoch: number | null
2656
+ created_at: number
2657
+ }
2658
+
2659
+ const RUN_ID_RE = /^run_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
2660
+
2661
+ export function isRunId(value: unknown): value is string {
2662
+ return typeof value === "string" && RUN_ID_RE.test(value)
2663
+ }
2664
+
2665
+ // SATU-SATUNYA allocator RunId produksi (CSPRNG; domain sesi, berbeda dari
2666
+ // exec_/dsp_/attempt — lihat keputusan §6 laporan: tak ada reuse).
2667
+ export function allocateRunId(): string {
2668
+ return `run_${randomUUID()}`
2669
+ }
2670
+
2671
+ export class RunStatusError extends Error {
2672
+ readonly code = "RUN_INVALID_TRANSITION"
2673
+ constructor(runId: string, from: string, to: string) {
2674
+ super(`[run] RUN_INVALID_TRANSITION ${runId}: ${from} → ${to} refused`)
2675
+ this.name = "RunStatusError"
2676
+ }
2677
+ }
2678
+
2679
+ export class RunTerminalConflictError extends Error {
2680
+ readonly code = "RUN_TERMINAL_CONFLICT"
2681
+ constructor(runId: string, from: string, to: string) {
2682
+ super(
2683
+ `[run] RUN_TERMINAL_CONFLICT ${runId}: already terminal ${from}, refusing conflicting ${to} (first terminal wins)`,
2684
+ )
2685
+ this.name = "RunTerminalConflictError"
2686
+ }
2687
+ }
2688
+
2689
+ export class RunRunningExistsError extends Error {
2690
+ readonly code = "RUNNING_EXISTS"
2691
+ constructor(sessionId: string) {
2692
+ super(`[run] RUNNING_EXISTS ${sessionId}: a RUNNING run already holds this session`)
2693
+ this.name = "RunRunningExistsError"
2694
+ }
2695
+ }
2696
+
2697
+ export class RunCursorError extends Error {
2698
+ readonly code: "RUN_CURSOR_BACKWARD" | "RUN_CURSOR_BEYOND_HEAD" | "RUN_CURSOR_FOREIGN"
2699
+ constructor(code: RunCursorError["code"], runId: string, detail: string) {
2700
+ super(`[run] ${code} ${runId}: ${detail}`)
2701
+ this.name = "RunCursorError"
2702
+ this.code = code
2703
+ }
2704
+ }
2705
+
2706
+ export class RunPendingError extends Error {
2707
+ readonly code = "RUN_PENDING_MALFORMED"
2708
+ constructor(detail: string) {
2709
+ super(`[run] RUN_PENDING_MALFORMED: ${detail}`)
2710
+ this.name = "RunPendingError"
2711
+ }
2712
+ }
2713
+
2714
+ function rowToRun(row: RunRow): RunRow {
2715
+ return { ...row }
2716
+ }
2717
+
2718
+ const RUN_COLUMNS =
2719
+ "run_id, session_id, thread_id, status, started_at, ended_at, last_persisted_seq, pending_tool_ids, recovery_status, takeover_epoch, created_at"
2720
+
2721
+ export function getRun(runId: string, cwd?: string): RunRow | null {
2722
+ const db = open(cwd)
2723
+ try {
2724
+ const row = db
2725
+ .prepare(`SELECT ${RUN_COLUMNS} FROM runs WHERE run_id = ?`)
2726
+ .get(runId) as RunRow | null
2727
+ return row ? rowToRun(row) : null
2728
+ } finally {
2729
+ db.close()
2730
+ }
2731
+ }
2732
+
2733
+ export function listSessionRuns(sessionId: string, cwd?: string): RunRow[] {
2734
+ const db = open(cwd)
2735
+ try {
2736
+ return (
2737
+ db
2738
+ .prepare(`SELECT ${RUN_COLUMNS} FROM runs WHERE session_id = ? ORDER BY started_at`)
2739
+ .all(sessionId) as RunRow[]
2740
+ ).map(rowToRun)
2741
+ } finally {
2742
+ db.close()
2743
+ }
2744
+ }
2745
+
2746
+ // RUNNING aktif sesi ini (0-atau-1 menurut partial index; defensif LIMIT 1).
2747
+ export function getActiveRun(sessionId: string, cwd?: string): RunRow | null {
2748
+ const db = open(cwd)
2749
+ try {
2750
+ const row = db
2751
+ .prepare(
2752
+ `SELECT ${RUN_COLUMNS} FROM runs WHERE session_id = ? AND status = 'RUNNING' LIMIT 1`,
2753
+ )
2754
+ .get(sessionId) as RunRow | null
2755
+ return row ? rowToRun(row) : null
2756
+ } finally {
2757
+ db.close()
2758
+ }
2759
+ }
2760
+
2761
+ // Penilaian pulih read-only (tak pernah memutasi): ketidakpastian TERSIMPAN
2762
+ // (recovery_status UNKNOWN) atau RUNNING tanpa holder hidup = UNKNOWN;
2763
+ // sisanya NONE. Persistensi resolusi milik fase mendatang; P2.6 hanya
2764
+ // menombak yang mati pasti + menilainya jujur.
2765
+ export function assessRunRecoveryStatus(run: RunRow): "NONE" | "UNKNOWN" {
2766
+ if (run.recovery_status === "UNKNOWN") return "UNKNOWN"
2767
+ if (run.status === "RUNNING") return "UNKNOWN"
2768
+ return "NONE"
2769
+ }
2770
+
2771
+ function validatePendingToolIds(value: unknown): string {
2772
+ if (!Array.isArray(value)) throw new RunPendingError("pending_tool_ids must be an array")
2773
+ if (value.length > 256) throw new RunPendingError("pending_tool_ids exceeds 256 entries")
2774
+ for (const entry of value) {
2775
+ if (typeof entry !== "string" || entry.length === 0 || entry.length > 512) {
2776
+ throw new RunPendingError("pending_tool_ids entries must be non-empty strings ≤512 chars")
2777
+ }
2778
+ }
2779
+ return JSON.stringify(value)
2780
+ }
2781
+
2782
+ // Satu jalur create produksi: validasi kepemilikan (thread milik sesi) +
2783
+ // pagar epoch + baris CREATED (kursor = head saat ini, netral) + epoch
2784
+ // takeover tercatat. Status awal SELALU CREATED; pemanggil yang
2785
+ // mempromosikan ke RUNNING via transitionRun (dua langkah eksplisit).
2786
+ export function createRun(
2787
+ sessionId: string,
2788
+ threadId: string,
319
2789
  cwd?: string,
320
- ): { id: string; created_at: number; updated_at?: number; cwd: string }[] {
2790
+ opts?: { runId?: string; pendingToolIds?: unknown; expectedEpoch?: number },
2791
+ ): RunRow {
321
2792
  const db = open(cwd)
322
2793
  try {
323
- const rows = db
2794
+ return db.transaction(() => {
2795
+ if (opts?.expectedEpoch !== undefined)
2796
+ assertWriterEpochInTxn(db, sessionId, opts.expectedEpoch)
2797
+ if (!sessionRowExistsInTxn(db, sessionId)) throw new Error(`session not found: ${sessionId}`)
2798
+ const thread = db
2799
+ .prepare("SELECT thread_id FROM threads WHERE session_id = ? AND thread_id = ?")
2800
+ .get(sessionId, threadId) as { thread_id: string } | null
2801
+ if (!thread) throw new Error(`thread not found: ${sessionId}/${threadId}`)
2802
+ const runId = opts?.runId ?? allocateRunId()
2803
+ if (!isRunId(runId)) throw new Error(`invalid run id: ${opts?.runId}`)
2804
+ const pending =
2805
+ opts?.pendingToolIds !== undefined ? validatePendingToolIds(opts.pendingToolIds) : "[]"
2806
+ const now = Date.now()
2807
+ const headRow = db
2808
+ .prepare("SELECT MAX(seq) AS m FROM messages WHERE session_id = ? AND thread_id = ?")
2809
+ .get(sessionId, threadId) as { m: number | null } | null
2810
+ // Head thread kosong = -1, tapi kursor run punya CHECK >= 0 dan harus
2811
+ // menunjuk posisi histori yang benar-benar durable: kursor awal 0 pada
2812
+ // thread kosong berarti "belum ada event milik run ini" (bukan klaim
2813
+ // bahwa seq 0 milik run ini — kepemilikan dicek saat advance).
2814
+ const head = Math.max(headRow?.m ?? -1, 0)
2815
+ const epochRow = db
2816
+ .prepare("SELECT writer_epoch AS epoch FROM sessions WHERE id = ?")
2817
+ .get(sessionId) as {
2818
+ epoch: number
2819
+ }
2820
+ db.prepare(
2821
+ "INSERT INTO runs (run_id, session_id, thread_id, status, started_at, ended_at, last_persisted_seq, pending_tool_ids, recovery_status, takeover_epoch, created_at) VALUES (?, ?, ?, 'CREATED', ?, NULL, ?, ?, 'NONE', ?, ?)",
2822
+ ).run(runId, sessionId, threadId, now, head, pending, epochRow.epoch, now)
2823
+ return rowToRun({
2824
+ run_id: runId,
2825
+ session_id: sessionId,
2826
+ thread_id: threadId,
2827
+ status: "CREATED",
2828
+ started_at: now,
2829
+ ended_at: null,
2830
+ last_persisted_seq: head,
2831
+ pending_tool_ids: pending,
2832
+ recovery_status: "NONE",
2833
+ takeover_epoch: epochRow.epoch,
2834
+ created_at: now,
2835
+ })
2836
+ })()
2837
+ } finally {
2838
+ db.close()
2839
+ }
2840
+ }
2841
+
2842
+ function sessionRowExistsInTxn(db: Database, sessionId: string): boolean {
2843
+ const row = db.prepare("SELECT 1 AS ok FROM sessions WHERE id = ?").get(sessionId) as {
2844
+ ok: number
2845
+ } | null
2846
+ return row !== null
2847
+ }
2848
+
2849
+ const RUN_EDGES: Record<RunStatus, readonly RunStatus[]> = {
2850
+ CREATED: ["RUNNING", "COMPLETED", "INTERRUPTED", "FAILED"],
2851
+ RUNNING: ["COMPLETED", "INTERRUPTED", "FAILED"],
2852
+ COMPLETED: ["COMPLETED"],
2853
+ INTERRUPTED: ["INTERRUPTED"],
2854
+ FAILED: ["FAILED"],
2855
+ }
2856
+
2857
+ // Transisi status fenced. Terminal→sama = idempoten (ended_at pertama menang);
2858
+ // terminal→beda = konflik (first terminal wins, bukan last-writer-wins).
2859
+ // RUNNING kedua konkuren = constraint partial-index → RUNNING_EXISTS terstruktur.
2860
+ export function transitionRun(
2861
+ runId: string,
2862
+ to: RunStatus,
2863
+ cwd?: string,
2864
+ opts?: { expectedEpoch?: number; recoveryStatus?: string },
2865
+ ): RunRow {
2866
+ const db = open(cwd)
2867
+ try {
2868
+ return db.transaction(() => {
2869
+ const row = db
2870
+ .prepare(`SELECT ${RUN_COLUMNS} FROM runs WHERE run_id = ?`)
2871
+ .get(runId) as RunRow | null
2872
+ if (!row) throw new Error(`run not found: ${runId}`)
2873
+ if (opts?.expectedEpoch !== undefined)
2874
+ assertWriterEpochInTxn(db, row.session_id, opts.expectedEpoch)
2875
+ // Terminal: dua kelas penolakan dibedakan agar diagnosis jujur —
2876
+ // terminal→terminal lain = konflik first-wins; terminal→non-terminal
2877
+ // = tepi ilegal (bukan "konflik" — tak ada klaim terminal kedua).
2878
+ if (RUN_TERMINAL.has(row.status)) {
2879
+ if (row.status === to) return rowToRun(row)
2880
+ if (RUN_TERMINAL.has(to)) throw new RunTerminalConflictError(runId, row.status, to)
2881
+ throw new RunStatusError(runId, row.status, to)
2882
+ }
2883
+ if (!RUN_EDGES[row.status].includes(to)) throw new RunStatusError(runId, row.status, to)
2884
+ const now = Date.now()
2885
+ const terminal = RUN_TERMINAL.has(to)
2886
+ const recovery = to === "INTERRUPTED" ? (opts?.recoveryStatus ?? "NONE") : "NONE"
2887
+ try {
2888
+ db.prepare(
2889
+ "UPDATE runs SET status = ?, ended_at = ?, recovery_status = ? WHERE run_id = ?",
2890
+ ).run(to, terminal ? now : null, recovery, runId)
2891
+ } catch (e) {
2892
+ if (isRunningUniquenessViolation(e)) throw new RunRunningExistsError(row.session_id)
2893
+ throw e
2894
+ }
2895
+ return rowToRun({
2896
+ ...row,
2897
+ status: to,
2898
+ ended_at: terminal ? now : row.ended_at,
2899
+ recovery_status: recovery,
2900
+ })
2901
+ })()
2902
+ } finally {
2903
+ db.close()
2904
+ }
2905
+ }
2906
+
2907
+ function isRunningUniquenessViolation(e: unknown): boolean {
2908
+ const msg = String((e as Error)?.message ?? e)
2909
+ return msg.includes("UNIQUE constraint failed") && msg.includes("runs")
2910
+ }
2911
+
2912
+ export function completeRun(
2913
+ runId: string,
2914
+ cwd?: string,
2915
+ opts?: { expectedEpoch?: number },
2916
+ ): RunRow {
2917
+ return transitionRun(runId, "COMPLETED", cwd, opts)
2918
+ }
2919
+
2920
+ export function failRun(runId: string, cwd?: string, opts?: { expectedEpoch?: number }): RunRow {
2921
+ return transitionRun(runId, "FAILED", cwd, opts)
2922
+ }
2923
+
2924
+ export function interruptRun(
2925
+ runId: string,
2926
+ cwd?: string,
2927
+ opts?: { expectedEpoch?: number; recoveryStatus?: string },
2928
+ ): RunRow {
2929
+ return transitionRun(runId, "INTERRUPTED", cwd, opts)
2930
+ }
2931
+
2932
+ // Kursor eksplisit: monoton (CAS pada nilai terbaca — tanpa lost-update),
2933
+ // dalam-head, milik-run ini (NULL warisan boleh; run lain ditolak).
2934
+ // Versi in-txn dipakai appendHistoryEvent supaya event+kursor satu commit.
2935
+ function advanceRunCursorInTxn(
2936
+ db: Database,
2937
+ runId: string,
2938
+ seq: number,
2939
+ expectSessionId: string | undefined,
2940
+ opts?: { expectedEventId?: string },
2941
+ ): RunRow {
2942
+ const row = db
2943
+ .prepare(`SELECT ${RUN_COLUMNS} FROM runs WHERE run_id = ?`)
2944
+ .get(runId) as RunRow | null
2945
+ if (!row) throw new Error(`run not found: ${runId}`)
2946
+ if (expectSessionId !== undefined && row.session_id !== expectSessionId)
2947
+ throw new Error(`run ${runId} does not belong to session ${expectSessionId}`)
2948
+ if (RUN_TERMINAL.has(row.status))
2949
+ throw new RunStatusError(runId, row.status, `${row.status}+cursor`)
2950
+ if (!Number.isInteger(seq) || seq < 0)
2951
+ throw new RunCursorError("RUN_CURSOR_BEYOND_HEAD", runId, `invalid seq ${seq}`)
2952
+ const target = db
2953
+ .prepare(
2954
+ "SELECT seq, run_id, event_id FROM messages WHERE session_id = ? AND thread_id = ? AND seq = ?",
2955
+ )
2956
+ .get(row.session_id, row.thread_id, seq) as {
2957
+ seq: number
2958
+ run_id: string | null
2959
+ event_id: string | null
2960
+ } | null
2961
+ if (!target)
2962
+ throw new RunCursorError("RUN_CURSOR_BEYOND_HEAD", runId, `no durable event at seq ${seq}`)
2963
+ if (target.run_id !== null && target.run_id !== runId) {
2964
+ throw new RunCursorError(
2965
+ "RUN_CURSOR_FOREIGN",
2966
+ runId,
2967
+ `seq ${seq} belongs to run ${target.run_id}`,
2968
+ )
2969
+ }
2970
+ if (opts?.expectedEventId !== undefined && target.event_id !== opts.expectedEventId) {
2971
+ throw new RunCursorError("RUN_CURSOR_FOREIGN", runId, `seq ${seq} event mismatch`)
2972
+ }
2973
+ if (seq < row.last_persisted_seq) {
2974
+ throw new RunCursorError(
2975
+ "RUN_CURSOR_BACKWARD",
2976
+ runId,
2977
+ `${row.last_persisted_seq} → ${seq} refused (no rewind in P2.6)`,
2978
+ )
2979
+ }
2980
+ if (seq === row.last_persisted_seq) return rowToRun(row)
2981
+ const upd = db
2982
+ .prepare("UPDATE runs SET last_persisted_seq = ? WHERE run_id = ? AND last_persisted_seq = ?")
2983
+ .run(seq, runId, row.last_persisted_seq)
2984
+ if (upd.changes === 0) {
2985
+ const cur = db.prepare("SELECT last_persisted_seq FROM runs WHERE run_id = ?").get(runId) as {
2986
+ last_persisted_seq: number
2987
+ }
2988
+ throw new RunCursorError(
2989
+ "RUN_CURSOR_BACKWARD",
2990
+ runId,
2991
+ `concurrent advance observed (now ${cur.last_persisted_seq})`,
2992
+ )
2993
+ }
2994
+ return rowToRun({ ...row, last_persisted_seq: seq })
2995
+ }
2996
+
2997
+ export function advanceRunCursor(
2998
+ runId: string,
2999
+ seq: number,
3000
+ cwd?: string,
3001
+ opts?: { expectedEpoch?: number; expectedEventId?: string },
3002
+ ): RunRow {
3003
+ const db = open(cwd)
3004
+ try {
3005
+ return db.transaction(() => {
3006
+ if (opts?.expectedEpoch !== undefined) {
3007
+ const owner = db.prepare("SELECT session_id FROM runs WHERE run_id = ?").get(runId) as {
3008
+ session_id: string
3009
+ } | null
3010
+ if (!owner) throw new Error(`run not found: ${runId}`)
3011
+ assertWriterEpochInTxn(db, owner.session_id, opts.expectedEpoch)
3012
+ }
3013
+ return advanceRunCursorInTxn(db, runId, seq, undefined, opts)
3014
+ })()
3015
+ } finally {
3016
+ db.close()
3017
+ }
3018
+ }
3019
+
3020
+ // Metadata pending_tool_ids (dorman P2.6): round-trip tervalidasi, fenced.
3021
+ // BUKAN bukti eksekusi — tak ada semantik tool di sini.
3022
+ export function setRunPendingTools(
3023
+ runId: string,
3024
+ pendingToolIds: unknown,
3025
+ cwd?: string,
3026
+ opts?: { expectedEpoch?: number },
3027
+ ): RunRow {
3028
+ const db = open(cwd)
3029
+ try {
3030
+ return db.transaction(() => {
3031
+ const row = db
3032
+ .prepare(`SELECT ${RUN_COLUMNS} FROM runs WHERE run_id = ?`)
3033
+ .get(runId) as RunRow | null
3034
+ if (!row) throw new Error(`run not found: ${runId}`)
3035
+ if (opts?.expectedEpoch !== undefined)
3036
+ assertWriterEpochInTxn(db, row.session_id, opts.expectedEpoch)
3037
+ const pending = validatePendingToolIds(pendingToolIds)
3038
+ db.prepare("UPDATE runs SET pending_tool_ids = ? WHERE run_id = ?").run(pending, runId)
3039
+ return rowToRun({ ...row, pending_tool_ids: pending })
3040
+ })()
3041
+ } finally {
3042
+ db.close()
3043
+ }
3044
+ }
3045
+
3046
+ // Tombstone crash-residue: SEMUA RUNNING sesi ini (tanpa holder hidup —
3047
+ // admission membuktikannya) menjadi INTERRUPTED + recovery UNKNOWN dengan
3048
+ // ended_at NULL (kematian tak terobservasi). Satu statement (atomik, tanpa
3049
+ // TOCTOU). BUKAN auto-continue/replay: resolusi milik fase mendatang.
3050
+ // Fenced; idempoten (pemanggilan kedua nihil).
3051
+ export function tombstoneDeadRuns(
3052
+ sessionId: string,
3053
+ cwd?: string,
3054
+ opts?: { expectedEpoch?: number },
3055
+ ): number {
3056
+ const db = open(cwd)
3057
+ try {
3058
+ return db.transaction(() => {
3059
+ if (opts?.expectedEpoch !== undefined)
3060
+ assertWriterEpochInTxn(db, sessionId, opts.expectedEpoch)
3061
+ const res = db
3062
+ .prepare(
3063
+ "UPDATE runs SET status = 'INTERRUPTED', recovery_status = 'UNKNOWN' WHERE session_id = ? AND status = 'RUNNING'",
3064
+ )
3065
+ .run(sessionId)
3066
+ return res.changes
3067
+ })()
3068
+ } finally {
3069
+ db.close()
3070
+ }
3071
+ }
3072
+
3073
+ // ── P2.7 — Projection foundation ────────────────────────────────────────────
3074
+ // Proyeksi = representasi TURUNAN dari messages (read-only build, rebuildable,
3075
+ // tak pernah otoritatif). Satu-satunya jenis P2.7: "summary" (ringkasan prefix).
3076
+ // base_seq EKSKLUSIF: base_seq = N ⟺ cakupan [0,N). Validitas TIDAK PERNAH
3077
+ // memakai run_id / last_persisted_seq (amendemen P2.6: kursor = watermark
3078
+ // posisional, bukan kepemilikan). Jangkar identitas = anchor_event_id.
3079
+
3080
+ // P2.7: satu-satunya projection_id yang diizinkan. Kosakata tetap (bukan
3081
+ // alokasi): jenis baru milik fase mendatang, tak boleh berspekulasi kini.
3082
+ export const SUMMARY_PROJECTION_ID = "summary"
3083
+ const PROJECTION_IDS = [SUMMARY_PROJECTION_ID] as const
3084
+ // Batas defensif ukuran ringkasan (murah vs budget token ringkasan LLM, namun
3085
+ // menolak baris multi-MB akibat misuse API). Bukan kebijakan token/budget.
3086
+ const MAX_PROJECTION_SUMMARY_CHARS = 512 * 1024
3087
+
3088
+ export class ProjectionValidationError extends Error {
3089
+ readonly code = "PROJECTION_INVALID"
3090
+ constructor(detail: string) {
3091
+ super(`[projection] PROJECTION_INVALID: ${detail}`)
3092
+ this.name = "ProjectionValidationError"
3093
+ }
3094
+ }
3095
+
3096
+ // P2.7: saveSession HANYA append-only. Riwayat menyusut/berubah isi menuntut
3097
+ // jalur eksplisit shrinkThreadHistory (provenance + invalidasi + pagar run).
3098
+ export class RefusedHistoryRewriteError extends Error {
3099
+ readonly code = "REFUSED_HISTORY_REWRITE"
3100
+ /**
3101
+ * True bila kanonik TUMBUH melampaui buffer (buffer = prefix sejati stored):
3102
+ * penulis lain menambah baris setelah buffer dibaca. Composition root WAJIB
3103
+ * menolak shrink otomatis pada kasus ini (baris penulis lain tak boleh
3104
+ * dihancurkan) — lihat I2. Dihitung di titik throw agar tak perlu query lagi.
3105
+ */
3106
+ readonly grewBeyondBuffer: boolean
3107
+ constructor(sessionId: string, threadId: string, detail: string, grewBeyondBuffer = false) {
3108
+ super(
3109
+ `[persist] REFUSED_HISTORY_REWRITE ${sessionId}/${threadId}: ${detail} — use shrinkThreadHistory`,
3110
+ )
3111
+ this.name = "RefusedHistoryRewriteError"
3112
+ this.grewBeyondBuffer = grewBeyondBuffer
3113
+ }
3114
+ }
3115
+
3116
+ // P2.7 Policy A: shrink dilarang selama ada RUNNING (tanpa rewind/clamp/rebase).
3117
+ export class RefusedShrinkLiveRunError extends Error {
3118
+ readonly code = "REFUSED_SHRINK_LIVE_RUN"
3119
+ constructor(sessionId: string) {
3120
+ super(
3121
+ `[persist] REFUSED_SHRINK_LIVE_RUN ${sessionId}: shrink requires no live RUNNING run (terminal-mark first)`,
3122
+ )
3123
+ this.name = "RefusedShrinkLiveRunError"
3124
+ }
3125
+ }
3126
+
3127
+ export interface ProjectionRow {
3128
+ session_id: string
3129
+ thread_id: string
3130
+ projection_id: string
3131
+ base_seq: number
3132
+ summary_text: string
3133
+ included_ranges: string
3134
+ built_at: number
3135
+ anchor_event_id: string | null
3136
+ }
3137
+
3138
+ export type ProjectionState = "CURRENT" | "STALE" | "INCOMPLETE" | "CORRUPT" | "UNKNOWN"
3139
+
3140
+ // P3.4 N1: detail STABLE untuk sub-kasus rule-8 (head maju, jangkar utuh) pada
3141
+ // getProjectionStatus. Diekspor agar pembaca (readConsumableSummaryProjection)
3142
+ // dapat membedakan STALE-rule-8 (coverage-valid, consumable) dari STALE-rule-7
3143
+ // (jangkar patah, TIDAK consumable) TANPA menduplikasi cek jangkar.
3144
+ export const PROJECTION_STALE_HEAD_ADVANCED_DETAIL = "head advanced beyond coverage"
3145
+
3146
+ export interface ProjectionStatus {
3147
+ state: ProjectionState
3148
+ detail: string
3149
+ }
3150
+
3151
+ const PROJECTION_COLUMNS =
3152
+ "session_id, thread_id, projection_id, base_seq, summary_text, included_ranges, built_at, anchor_event_id"
3153
+
3154
+ function rowToProjection(row: ProjectionRow): ProjectionRow {
3155
+ return { ...row }
3156
+ }
3157
+
3158
+ function validateProjectionId(projectionId: string): void {
3159
+ if (!(PROJECTION_IDS as readonly string[]).includes(projectionId)) {
3160
+ throw new ProjectionValidationError(
3161
+ `unknown projection_id "${projectionId}" (allowed: ${PROJECTION_IDS.join(", ")})`,
3162
+ )
3163
+ }
3164
+ }
3165
+
3166
+ // Validasi ketat bentuk kanonik P2.7: [] atau [[0,N]]. Bukan normalisasi —
3167
+ // pembaca tak pernah memperbaiki data tersimpan (temuan korupsi = CORRUPT).
3168
+ function parseIncludedRangesStrict(raw: string): { ok: true; end: number } | { ok: false } {
3169
+ let parsed: unknown
3170
+ try {
3171
+ parsed = JSON.parse(raw)
3172
+ } catch {
3173
+ return { ok: false }
3174
+ }
3175
+ if (!Array.isArray(parsed)) return { ok: false }
3176
+ if (parsed.length === 0) return { ok: true, end: 0 }
3177
+ if (parsed.length !== 1) return { ok: false }
3178
+ const only = parsed[0]
3179
+ if (!Array.isArray(only) || only.length !== 2) return { ok: false }
3180
+ const [start, end] = only as unknown[]
3181
+ if (!Number.isInteger(start) || !Number.isInteger(end)) return { ok: false }
3182
+ if ((start as number) !== 0 || (end as number) <= 0) return { ok: false }
3183
+ return { ok: true, end: end as number }
3184
+ }
3185
+
3186
+ function canonicalRangesFor(baseSeq: number): string {
3187
+ return baseSeq === 0 ? "[]" : JSON.stringify([[0, baseSeq]])
3188
+ }
3189
+
3190
+ function threadHeadInTxn(db: Database, sessionId: string, threadId: string): number {
3191
+ const row = db
3192
+ .prepare("SELECT MAX(seq) AS m FROM messages WHERE session_id = ? AND thread_id = ?")
3193
+ .get(sessionId, threadId) as { m: number | null } | null
3194
+ return row?.m ?? -1
3195
+ }
3196
+
3197
+ // Kepala thread (baca-saja, tanpa txn tulis). Dipakai composition root untuk
3198
+ // mendeteksi shrink sebelum memilih jalur persist.
3199
+ export function getThreadHead(sessionId: string, threadId: string, cwd?: string): number {
3200
+ const db = open(cwd)
3201
+ try {
3202
+ return threadHeadInTxn(db, sessionId, threadId)
3203
+ } finally {
3204
+ db.close()
3205
+ }
3206
+ }
3207
+
3208
+ // Baca proyeksi mentah (tanpa penilaian). NULL = "tak ada proyeksi" (bukan
3209
+ // histori kosong — fallback ke messages milik pemanggil, di luar otoritas ini).
3210
+ export function getProjection(
3211
+ sessionId: string,
3212
+ threadId: string,
3213
+ projectionId: string,
3214
+ cwd?: string,
3215
+ ): ProjectionRow | null {
3216
+ validateProjectionId(projectionId)
3217
+ const db = open(cwd)
3218
+ try {
3219
+ const row = db
324
3220
  .prepare(
325
- "SELECT id, created_at, updated_at, cwd FROM sessions ORDER BY COALESCE(updated_at, created_at) DESC LIMIT 50",
3221
+ `SELECT ${PROJECTION_COLUMNS} FROM history_projections WHERE session_id = ? AND thread_id = ? AND projection_id = ?`,
326
3222
  )
327
- .all() as { id: string; created_at: number; updated_at: number | null; cwd: string }[]
328
- return rows.map((r) => ({ ...r, updated_at: r.updated_at ?? r.created_at }))
3223
+ .get(sessionId, threadId, projectionId) as ProjectionRow | null
3224
+ return row ? rowToProjection(row) : null
329
3225
  } finally {
330
3226
  db.close()
331
3227
  }
332
3228
  }
333
3229
 
334
- export async function deleteSession(id: string, cwd?: string) {
3230
+ // Mesin validitas deterministik (kontrak §8). Murni baca; tak pernah rebuild,
3231
+ // tak pernah mutasi, tak pernah memakai run_id/kursor.
3232
+ export function getProjectionStatus(
3233
+ sessionId: string,
3234
+ threadId: string,
3235
+ projectionId: string,
3236
+ cwd?: string,
3237
+ ): ProjectionStatus {
3238
+ validateProjectionId(projectionId)
3239
+ const db = open(cwd)
3240
+ try {
3241
+ const thread = db
3242
+ .prepare("SELECT 1 AS ok FROM threads WHERE session_id = ? AND thread_id = ?")
3243
+ .get(sessionId, threadId) as { ok: number } | null
3244
+ // 1. Thread hilang (baris yatim) → tak dapat dibuktikan → UNKNOWN.
3245
+ if (!thread) return { state: "UNKNOWN", detail: "thread row missing" }
3246
+ const row = db
3247
+ .prepare(
3248
+ `SELECT ${PROJECTION_COLUMNS} FROM history_projections WHERE session_id = ? AND thread_id = ? AND projection_id = ?`,
3249
+ )
3250
+ .get(sessionId, threadId, projectionId) as ProjectionRow | null
3251
+ // Baris absen = "tak ada proyeksi" (bukan klaim apa pun).
3252
+ if (!row) return { state: "UNKNOWN", detail: "no projection row" }
3253
+ const head = threadHeadInTxn(db, sessionId, threadId)
3254
+ // 2. Bentuk tak-kanonik → CORRUPT (pembaca tak memperbaiki data).
3255
+ const parsed = parseIncludedRangesStrict(row.included_ranges)
3256
+ if (!parsed.ok) return { state: "CORRUPT", detail: "included_ranges not canonical" }
3257
+ // 3. base_seq wajib sama dengan ujung cakupan.
3258
+ if (!Number.isInteger(row.base_seq) || row.base_seq < 0 || row.base_seq !== parsed.end) {
3259
+ return { state: "CORRUPT", detail: "base_seq != coverage end" }
3260
+ }
3261
+ // 4. Cakupan kosong + ringkasan isi → INCOMPLETE.
3262
+ if (parsed.end === 0) {
3263
+ return row.summary_text === ""
3264
+ ? { state: "CURRENT", detail: "empty coverage, empty summary" }
3265
+ : { state: "INCOMPLETE", detail: "empty coverage with summary content" }
3266
+ }
3267
+ // 5. Klaim di luar kemungkinan → CORRUPT (jalur shrink menghapus proyeksi
3268
+ // yang terdampak secara atomik, jadi yang selamat namun mustahil = rusak).
3269
+ if (row.base_seq > head + 1) {
3270
+ return { state: "CORRUPT", detail: "base_seq beyond head+1" }
3271
+ }
3272
+ // 6. Jangkar hilang padahal cakupan isi → CORRUPT (invariant penulis).
3273
+ if (row.anchor_event_id === null) {
3274
+ return { state: "CORRUPT", detail: "missing anchor_event_id" }
3275
+ }
3276
+ // 7. Baris batas hilang/berubah identitas → STALE (sumber bergerak).
3277
+ const anchor = db
3278
+ .prepare("SELECT event_id FROM messages WHERE session_id = ? AND thread_id = ? AND seq = ?")
3279
+ .get(sessionId, threadId, row.base_seq - 1) as { event_id: string | null } | null
3280
+ if (!anchor || anchor.event_id !== row.anchor_event_id) {
3281
+ return { state: "STALE", detail: "boundary event changed or gone" }
3282
+ }
3283
+ // 8. Kepala melampaui cakupan → STALE (ada baris baru tak-tercakup).
3284
+ if (head >= row.base_seq) return { state: "STALE", detail: "head advanced beyond coverage" }
3285
+ // 9. head == base_seq-1 + jangkar cocok → CURRENT.
3286
+ return { state: "CURRENT", detail: "coverage matches head, anchor holds" }
3287
+ } finally {
3288
+ db.close()
3289
+ }
3290
+ }
3291
+
3292
+ // Inti build DALAM txn pemanggil: validasi → hapus-baris-lama → sisipkan.
3293
+ // Dipakai buildProjection (mandiri) dan rebuildProjection (nama eksplisit).
3294
+ // summaryText dari PEMANGGIL (seam kompaksi yang ada) — lapisan ini tak pernah
3295
+ // membangkitkan teks (tanpa LLM, tanpa vendor, tanpa run/cursor).
3296
+ function buildProjectionInTxn(
3297
+ db: Database,
3298
+ sessionId: string,
3299
+ threadId: string,
3300
+ projectionId: string,
3301
+ summaryText: string,
3302
+ baseSeq: number | undefined,
3303
+ ): ProjectionRow {
3304
+ validateProjectionId(projectionId)
3305
+ if (!sessionRowExistsInTxn(db, sessionId)) throw new Error(`session not found: ${sessionId}`)
3306
+ const thread = db
3307
+ .prepare("SELECT 1 AS ok FROM threads WHERE session_id = ? AND thread_id = ?")
3308
+ .get(sessionId, threadId) as { ok: number } | null
3309
+ if (!thread) throw new Error(`thread not found: ${sessionId}/${threadId}`)
3310
+ const head = threadHeadInTxn(db, sessionId, threadId)
3311
+ const b = baseSeq ?? head + 1
3312
+ if (!Number.isInteger(b) || b < 0 || b > head + 1) {
3313
+ throw new ProjectionValidationError(`base_seq ${String(b)} out of [0, head+1=${head + 1}]`)
3314
+ }
3315
+ if (typeof summaryText !== "string")
3316
+ throw new ProjectionValidationError("summary_text not a string")
3317
+ if (summaryText.length > MAX_PROJECTION_SUMMARY_CHARS) {
3318
+ throw new ProjectionValidationError("summary_text exceeds size cap")
3319
+ }
3320
+ // Emisi kanonik: cakupan kosong ⟺ ringkasan kosong (fail-closed di penulis;
3321
+ // baris INCOMPLETE hanya bisa datang dari tulisan tangan, dibaca jujur).
3322
+ if ((b === 0) !== (summaryText === "")) {
3323
+ throw new ProjectionValidationError("empty coverage requires empty summary and vice versa")
3324
+ }
3325
+ // Jangkar identitas batas + bukti tak ada event_id NULL dalam cakupan
3326
+ // (fail-closed: taksir tak boleh menutupi lubang identitas).
3327
+ let anchor: string | null = null
3328
+ if (b > 0) {
3329
+ const row = db
3330
+ .prepare("SELECT event_id FROM messages WHERE session_id = ? AND thread_id = ? AND seq = ?")
3331
+ .get(sessionId, threadId, b - 1) as { event_id: string | null } | null
3332
+ if (!row || row.event_id === null) {
3333
+ throw new ProjectionValidationError("boundary event missing event_id")
3334
+ }
3335
+ anchor = row.event_id
3336
+ const holes = db
3337
+ .prepare(
3338
+ "SELECT COUNT(*) AS n FROM messages WHERE session_id = ? AND thread_id = ? AND seq < ? AND event_id IS NULL",
3339
+ )
3340
+ .get(sessionId, threadId, b) as { n: number }
3341
+ if (holes.n > 0) throw new ProjectionValidationError("covered range has NULL event_id rows")
3342
+ }
3343
+ const now = Date.now()
3344
+ const ranges = canonicalRangesFor(b)
3345
+ db.prepare(
3346
+ "DELETE FROM history_projections WHERE session_id = ? AND thread_id = ? AND projection_id = ?",
3347
+ ).run(sessionId, threadId, projectionId)
3348
+ db.prepare(
3349
+ "INSERT INTO history_projections (session_id, thread_id, projection_id, base_seq, summary_text, included_ranges, built_at, anchor_event_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
3350
+ ).run(sessionId, threadId, projectionId, b, summaryText, ranges, now, anchor)
3351
+ return {
3352
+ session_id: sessionId,
3353
+ thread_id: threadId,
3354
+ projection_id: projectionId,
3355
+ base_seq: b,
3356
+ summary_text: summaryText,
3357
+ included_ranges: ranges,
3358
+ built_at: now,
3359
+ anchor_event_id: anchor,
3360
+ }
3361
+ }
3362
+
3363
+ // Jalur build kanonik: baca histori komit → validasi → ganti baris, SATU txn
3364
+ // berpagar. Tak menyentuh messages (baca-saja atas sumber).
3365
+ export function buildProjection(
3366
+ sessionId: string,
3367
+ threadId: string,
3368
+ summaryText: string,
3369
+ cwd?: string,
3370
+ opts?: { expectedEpoch?: number; baseSeq?: number; projectionId?: string },
3371
+ ): ProjectionRow {
3372
+ if (opts?.expectedEpoch === undefined) {
3373
+ throw new ProjectionValidationError("expectedEpoch is required for projection mutation")
3374
+ }
3375
+ const db = open(cwd)
3376
+ try {
3377
+ return db.transaction(() => {
3378
+ assertWriterEpochInTxn(db, sessionId, opts.expectedEpoch as number)
3379
+ return buildProjectionInTxn(
3380
+ db,
3381
+ sessionId,
3382
+ threadId,
3383
+ opts?.projectionId ?? SUMMARY_PROJECTION_ID,
3384
+ summaryText,
3385
+ opts?.baseSeq,
3386
+ )
3387
+ })()
3388
+ } finally {
3389
+ db.close()
3390
+ }
3391
+ }
3392
+
3393
+ // Rebuild eksplisit = build ulang dari messages kanonik (semantik identik,
3394
+ // nama eksplisit untuk niat). Idempoten: sumber sama → baris ekuivalen semantik
3395
+ // (built_at boleh beda — stempel waktu, bukan klaim cakupan). Pagar sendiri
3396
+ // (bukan delegasi) agar setiap mutator publik visibel berpagar di guard statis.
3397
+ export function rebuildProjection(
3398
+ sessionId: string,
3399
+ threadId: string,
3400
+ summaryText: string,
3401
+ cwd?: string,
3402
+ opts?: { expectedEpoch?: number; baseSeq?: number; projectionId?: string },
3403
+ ): ProjectionRow {
3404
+ if (opts?.expectedEpoch === undefined) {
3405
+ throw new ProjectionValidationError("expectedEpoch is required for projection mutation")
3406
+ }
3407
+ const db = open(cwd)
3408
+ try {
3409
+ return db.transaction(() => {
3410
+ assertWriterEpochInTxn(db, sessionId, opts.expectedEpoch as number)
3411
+ return buildProjectionInTxn(
3412
+ db,
3413
+ sessionId,
3414
+ threadId,
3415
+ opts?.projectionId ?? SUMMARY_PROJECTION_ID,
3416
+ summaryText,
3417
+ opts?.baseSeq,
3418
+ )
3419
+ })()
3420
+ } finally {
3421
+ db.close()
3422
+ }
3423
+ }
3424
+
3425
+ // Jalur shrink EKSPLISIT pengganti cabang DELETE+rewrite implisit saveSession.
3426
+ // Urutan kontrak: pagar → tolak run live → ukur head (transien, tak disimpan)
3427
+ // → hapus proyeksi thread → ganti histori → tandai baris ringkasan → commit.
3428
+ // Baris adopsi identik mempertahankan identitas+atribusi; slot baru mendapat
3429
+ // event_id fresh, run_id NULL, migrated_compacted=1 (provenance, bukan klaim
3430
+ // rekonstruksi). turns tak tersentuh (catatan turn ≠ posisi seq).
3431
+ export function shrinkThreadHistory(
3432
+ sessionId: string,
3433
+ threadId: string,
3434
+ newMessages: readonly unknown[],
3435
+ cwd?: string,
3436
+ opts?: { expectedEpoch?: number },
3437
+ ): { oldHead: number; newHead: number } {
3438
+ if (opts?.expectedEpoch === undefined) {
3439
+ throw new ProjectionValidationError("expectedEpoch is required for history shrink")
3440
+ }
3441
+ const db = open(cwd)
3442
+ const now = Date.now()
3443
+ try {
3444
+ return db.transaction(() => {
3445
+ assertWriterEpochInTxn(db, sessionId, opts.expectedEpoch as number)
3446
+ if (!sessionRowExistsInTxn(db, sessionId)) throw new Error(`session not found: ${sessionId}`)
3447
+ // Thread default dijamin ada (migrasi kolom belum mematerialisasikannya;
3448
+ // jalur shrink boleh instantiate atomik — sama seperti saveSession).
3449
+ ensureDefaultThreadInTxn(db, sessionId, now)
3450
+ const thread = db
3451
+ .prepare("SELECT status FROM threads WHERE session_id = ? AND thread_id = ?")
3452
+ .get(sessionId, threadId) as { status: string } | null
3453
+ if (!thread) throw new Error(`thread not found: ${sessionId}/${threadId}`)
3454
+ if (thread.status === "archived") throw new ThreadArchivedError(sessionId, threadId)
3455
+ // Policy A: tanpa rewind/clamp/rebase diam-diam — shrink di bawah run
3456
+ // live DITOLAK eksplisit (terminal-mark dulu di composition root).
3457
+ const live = db
3458
+ .prepare("SELECT 1 AS ok FROM runs WHERE session_id = ? AND status = 'RUNNING'")
3459
+ .get(sessionId) as { ok: number } | null
3460
+ if (live) throw new RefusedShrinkLiveRunError(sessionId)
3461
+ // Kepala pra-shrink: pengukuran transien (cakup penghapusan), tak pernah
3462
+ // disimpan sebagai provenance (kontrak: tak ada konsumen old/new head).
3463
+ const oldHead = threadHeadInTxn(db, sessionId, threadId)
3464
+ const stored = db
3465
+ .prepare(
3466
+ "SELECT seq, role, content, toolCalls, toolCallId, name, reasoning, is_error, event_id, run_id, migrated, migrated_compacted, projection_note FROM messages WHERE session_id = ? AND thread_id = ? ORDER BY seq",
3467
+ )
3468
+ .all(sessionId, threadId) as {
3469
+ seq: number
3470
+ role: string
3471
+ content: string
3472
+ toolCalls: string
3473
+ toolCallId: string | null
3474
+ name: string | null
3475
+ reasoning: string | null
3476
+ is_error: number | null
3477
+ event_id: string | null
3478
+ run_id: string | null
3479
+ migrated: number
3480
+ migrated_compacted: number
3481
+ projection_note: string | null
3482
+ }[]
3483
+ const ins = db.prepare(
3484
+ "INSERT INTO messages (session_id, thread_id, seq, role, content, toolCalls, toolCallId, name, reasoning, is_error, ts, event_id, run_id, migrated, migrated_compacted, projection_note) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
3485
+ )
3486
+ db.prepare("DELETE FROM messages WHERE session_id = ? AND thread_id = ?").run(
3487
+ sessionId,
3488
+ threadId,
3489
+ )
3490
+ for (let i = 0; i < newMessages.length; i++) {
3491
+ const m = newMessages[i] as StoredMsg
3492
+ const w = normalizeMessageTupleForDedup(m)
3493
+ const got = stored[i]
3494
+ const same =
3495
+ got !== undefined &&
3496
+ got.seq === i &&
3497
+ got.role === w[0] &&
3498
+ got.content === w[1] &&
3499
+ got.toolCalls === w[2] &&
3500
+ (got.toolCallId ?? null) === w[3] &&
3501
+ (got.name ?? null) === w[4] &&
3502
+ (got.reasoning ?? null) === w[5] &&
3503
+ (got.is_error ?? 0) === w[6]
3504
+ if (same) {
3505
+ // Adopsi: identitas + atribusi + flag warisan dipertahankan utuh.
3506
+ ins.run(
3507
+ sessionId,
3508
+ threadId,
3509
+ i,
3510
+ w[0],
3511
+ w[1],
3512
+ w[2],
3513
+ w[3],
3514
+ w[4],
3515
+ w[5],
3516
+ w[6],
3517
+ now,
3518
+ got.event_id ?? allocateHistoryEventId(),
3519
+ got.run_id,
3520
+ got.migrated,
3521
+ got.migrated_compacted,
3522
+ got.projection_note,
3523
+ )
3524
+ } else {
3525
+ // Slot baru/berubah: identitas fresh, tanpa atribusi run (proyeksi
3526
+ // dan validitas tak boleh membaca klaim palsu), provenance shrink.
3527
+ ins.run(
3528
+ sessionId,
3529
+ threadId,
3530
+ i,
3531
+ w[0],
3532
+ w[1],
3533
+ w[2],
3534
+ w[3],
3535
+ w[4],
3536
+ w[5],
3537
+ w[6],
3538
+ now,
3539
+ allocateHistoryEventId(),
3540
+ null,
3541
+ 0,
3542
+ 1,
3543
+ null,
3544
+ )
3545
+ }
3546
+ }
3547
+ // Shrink menomori ulang seq: proyeksi thread mana pun tak lagi valid —
3548
+ // hapus SEMUA dalam txn yang sama (tak ada proyeksi basi yang selamat).
3549
+ db.prepare("DELETE FROM history_projections WHERE session_id = ? AND thread_id = ?").run(
3550
+ sessionId,
3551
+ threadId,
3552
+ )
3553
+ const newHead = recomputeThreadHeadInTxn(db, sessionId, threadId)
3554
+ return { oldHead, newHead }
3555
+ })()
3556
+ } finally {
3557
+ db.close()
3558
+ }
3559
+ }
3560
+
3561
+ /**
3562
+ * [PHASE 6Q] THE CANONICAL SESSION DELETION OPERATION.
3563
+ * 6N F6 found that there were two session-teardown paths and only one of them
3564
+ * cleaned up tasks: `deleteSession` did (6K D4) and `purgeExpired` did not, so a
3565
+ * TTL-purged session orphaned its task rows AND their execution lineage forever.
3566
+ * 6O ADR-9 concluded the second deletion architecture *is* the bug.
3567
+ *
3568
+ * This is the one operation. `deleteSession` and `purgeExpired` both call it.
3569
+ *
3570
+ * ORDERING, and why it is not negotiable:
3571
+ *
3572
+ * 1 bump the session incarnation <- invalidate every in-flight execution
3573
+ * 2 delete TaskStore rows <- tasks.db
3574
+ * 3 delete session-side rows <- sessions.db
3575
+ *
3576
+ * Step 1 first is what closes 6N F2 across process boundaries: an execution that
3577
+ * is still running against this session id now finds a moved incarnation and its
3578
+ * completion is REFUSED, so it can never stamp a marker onto a session that has
3579
+ * been deleted - or onto a later RECREATION of the same id, whose task ids are
3580
+ * indistinguishable from the deleted ones.
3581
+ *
3582
+ * Steps 2 and 3 preserve the 6K conclusion verbatim: tasks first, because the two
3583
+ * failure residues are not symmetric. A task-delete failure leaves the session
3584
+ * visible and the deletion visibly incomplete, so it is retryable and nothing is
3585
+ * orphaned. A session-first failure would leave task rows that are still
3586
+ * EXECUTABLE with no session to reconcile them - the dangerous residue.
3587
+ *
3588
+ * NOT ATOMIC, and deliberately not pretending to be: `tasks.db` and `sessions.db`
3589
+ * are separate persistence domains and no transaction spans them. The requirement
3590
+ * is not imaginary atomicity but that every reachable partial state is safe,
3591
+ * visible and retryable. Those residues are:
3592
+ *
3593
+ * fail at 1 -> nothing deleted; the session is intact and still usable. Safe.
3594
+ * fail at 2 -> incarnation already moved, so any in-flight execution is
3595
+ * already invalidated; task rows remain but the session is still
3596
+ * there. Visible, retryable, and NOT executable by a stale claim.
3597
+ * fail at 3 -> tasks are gone (so nothing executable survives), session rows
3598
+ * remain. Visible, retryable, no autonomous work can exist.
3599
+ *
3600
+ * IDEMPOTENT: every step is safe to repeat, and repeating advances the
3601
+ * incarnation again, which can only ever invalidate MORE stale executions.
3602
+ */
3603
+ async function deleteSessionCompletely(id: string, cwd?: string): Promise<void> {
3604
+ const { TaskStore } = await import("../task/store.ts")
3605
+ const tasks = new TaskStore(cwd)
3606
+
3607
+ // 1. Invalidate in-flight executions BEFORE removing anything they could write.
3608
+ tasks.bumpSessionIncarnation(id)
3609
+ // [PHASE 6U] Tell live local executions to STOP, before their rows disappear.
3610
+ //
3611
+ // [DESIGN DECISION] The incarnation bump above is the AUTHORITATIVE barrier: it
3612
+ // is durable, cross-process, and nothing can write after it. This notification
3613
+ // is strictly an OPTIMISATION layered in front of it — it makes a running
3614
+ // autonomous turn stop now instead of running to completion against a session
3615
+ // that no longer exists.
3616
+ //
3617
+ // Ordering is deliberate and matches 6Q's: invalidate durably FIRST, then
3618
+ // signal, then delete. A subscriber that somehow still writes is refused by the
3619
+ // bump regardless of what this notification did, so a broken subscriber cannot
3620
+ // turn into a resurrected session.
3621
+ const { notifySessionInvalidated } = await import("../task/session-ownership.ts")
3622
+ notifySessionInvalidated(id)
3623
+
3624
+ // 2. TaskStore rows, NOT best-effort, and still first among the deletions.
3625
+ try {
3626
+ tasks.deleteSessionTasks(id)
3627
+ } catch (e) {
3628
+ throw new Error(
3629
+ `deleteSession: task store cleanup failed for ${id}; session state left intact so the delete can be retried: ${(e as Error).message}`,
3630
+ )
3631
+ }
3632
+ // 3. Session-side rows.
335
3633
  const db = open(cwd)
336
3634
  const txn = db.transaction(() => {
337
3635
  db.prepare("DELETE FROM messages WHERE session_id = ?").run(id)
338
3636
  db.prepare("DELETE FROM turns WHERE session_id = ?").run(id)
3637
+ db.prepare("DELETE FROM presentation_events WHERE session_id = ?").run(id)
339
3638
  db.prepare("DELETE FROM sessions WHERE id = ?").run(id)
3639
+ // P2.9: anak Sub-Agent milik sesi yang dihapus ikut dibersihkan (garis
3640
+ // durable yang sama). Cascade eksplisit per-sesi (tanpa FK, sesuai
3641
+ // konvensi repo) — child TIDAK boleh jadi yatim yang masih RUNNING.
3642
+ const kids = db.prepare("SELECT id FROM sessions WHERE parent_session_id = ?").all(id) as {
3643
+ id: string
3644
+ }[]
3645
+ for (const kid of kids) {
3646
+ db.prepare("DELETE FROM history_projections WHERE session_id = ?").run(kid.id)
3647
+ db.prepare("DELETE FROM runs WHERE session_id = ?").run(kid.id)
3648
+ db.prepare("DELETE FROM threads WHERE session_id = ?").run(kid.id)
3649
+ db.prepare("DELETE FROM messages WHERE session_id = ?").run(kid.id)
3650
+ db.prepare("DELETE FROM turns WHERE session_id = ?").run(kid.id)
3651
+ db.prepare("DELETE FROM presentation_events WHERE session_id = ?").run(kid.id)
3652
+ db.prepare("DELETE FROM sessions WHERE id = ?").run(kid.id)
3653
+ }
3654
+ // P2.2: peta alias + rekaman takeover ikut terhapus (satu txn sama).
3655
+ // Alias yatim ke sesi mati akan menggantung (resolve menolak via cek
3656
+ // baris, tapi akumulasi membingungkan audit); takeover yatim mengaburkan
3657
+ // generasi. Recreate id yang sama mulai bersih di SEMUA sumbu — selaras
3658
+ // dengan bump inkarnasi TaskStore (langkah 1 di atas).
3659
+ db.prepare("DELETE FROM session_aliases WHERE canonical = ?").run(id)
3660
+ db.prepare("DELETE FROM session_takeovers WHERE session_id = ?").run(id)
3661
+ // P2.4: baris Thread sesi ini (strict: handle selalu via open()).
3662
+ db.prepare("DELETE FROM threads WHERE session_id = ?").run(id)
3663
+ // P2.6: Run sesi ini ikut mati — recreate id yang sama tak boleh
3664
+ // mewarisi residu RUNNING/UNKNOWN dari incarnasi sebelumnya.
3665
+ db.prepare("DELETE FROM runs WHERE session_id = ?").run(id)
3666
+ db.prepare("DELETE FROM history_projections WHERE session_id = ?").run(id)
340
3667
  })
341
3668
  try {
342
3669
  await withBusyRetry(() => txn())
343
3670
  } finally {
344
3671
  db.close()
345
3672
  }
3673
+ }
3674
+
3675
+ export async function deleteSession(id: string, cwd?: string) {
3676
+ // [PHASE 6K] TaskStore rows FIRST, and NOT best-effort.
3677
+ //
3678
+ // Phase 6J (D4, HIGH): this function deleted session-side state and never
3679
+ // touched `tasks.db` at all - `deleteTask`/`deleteSessionTasks` had zero
3680
+ // production callers. Deleting a session and recreating it with the same id
3681
+ // therefore resurrected the old task rows *with their execution lineage*, and
3682
+ // a Scheduler on the recreated session dispatched that deleted work.
3683
+ //
3684
+ // ORDERING (6K §8, two databases, so NOT atomic): tasks are removed BEFORE
3685
+ // session-side state. The two stores are separate files, so no single
3686
+ // transaction spans them. The ordering is chosen because the two possible
3687
+ // residues are not symmetric:
3688
+ //
3689
+ // task delete fails first -> the session still exists, so the delete is
3690
+ // visibly incomplete and retryable, and nothing
3691
+ // is orphaned. BENIGN.
3692
+ // session delete fails after -> the session exists with no tasks. Also
3693
+ // benign: a retry is a no-op for tasks and then
3694
+ // completes the session delete. CONVERGES.
3695
+ //
3696
+ // The reverse order would produce the dangerous residue (tasks surviving a
3697
+ // deleted session) on the first failure. That is why tasks go first.
3698
+ //
3699
+ // It is NOT swallowed: if task deletion fails we deliberately leave the
3700
+ // session intact and propagate, because continuing would delete the session
3701
+ // and leave exactly the executable orphans this fix exists to prevent.
3702
+ // [PHASE 6Q] The canonical operation owns the incarnation bump + TaskStore
3703
+ // cleanup + session-row deletion, so this function cannot drift from the
3704
+ // ordering or the failure semantics proved there. This replaces the inline
3705
+ // TaskStore block that 6K added.
3706
+ await deleteSessionCompletely(id, cwd)
346
3707
  // Lifecycle: jurnal ikut hapus sesi (best-effort; tak boleh gagalkan hapus).
347
3708
  try {
348
3709
  const { deleteJournalFile } = await import("./journal.ts")
@@ -354,18 +3715,17 @@ export async function deleteSession(id: string, cwd?: string) {
354
3715
  const { sanitizeSessionId } = await import("./checkpoint.ts")
355
3716
  const { rm } = await import("node:fs/promises")
356
3717
  const { resolve: resolvePath, join: joinPath } = await import("node:path")
357
- await rm(
358
- joinPath(
359
- resolvePath(cwd ?? process.cwd()),
360
- ".minicode",
361
- "checkpoints",
362
- sanitizeSessionId(id),
363
- ),
364
- {
365
- recursive: true,
366
- force: true,
367
- },
368
- ).catch(() => {})
3718
+ const { assertDeletableTarget } = await import("../lib/safe-open.ts")
3719
+ const base = resolvePath(cwd ?? process.cwd())
3720
+ const cpDir = joinPath(base, ".minicode", "checkpoints", sanitizeSessionId(id))
3721
+ // Gerbang fail-closed (Fase 0A): hapus hanya terbukti anak dari `base`.
3722
+ // Jalur ini best-effort, jadi kegagalan gerbang = LEWATI, bukan lempar keluar.
3723
+ const safeCp = await assertDeletableTarget(
3724
+ cpDir,
3725
+ { root: base, tempScoped: false },
3726
+ { recursive: true },
3727
+ ).catch(() => null)
3728
+ if (safeCp) await rm(safeCp, { recursive: true, force: true }).catch(() => {})
369
3729
  } catch {}
370
3730
  // Audit #10 §17: ref shadow-git (`refs/minicode/<sesi>/*`) menunjuk tree
371
3731
  // berisi ISI file saat snapshot — tanpa prune, konten sesi yang dihapus
@@ -395,12 +3755,21 @@ export async function deleteSession(id: string, cwd?: string) {
395
3755
  // P13 P1 — branch: fork sesi (history + turns) ke id baru tanpa menyentuh
396
3756
  // sumber. Butuh untuk "coba dua arah dari titik yang sama" — tanpa ini user
397
3757
  // harus mengulang seluruh percakapan untuk eksplorasi alternatif.
398
- export async function branchSession(srcId: string, dstId: string, cwd?: string): Promise<number> {
3758
+ // P2.4: salinan membawa thread_id/event_id/run_id/migrated (identitas
3759
+ // thread src, cakupan komposit dst). Baris default Thread dst dipastikan ada
3760
+ // (garis otoritas baru, epoch 0). Fenced bila expectedEpoch disediakan.
3761
+ export async function branchSession(
3762
+ srcId: string,
3763
+ dstId: string,
3764
+ cwd?: string,
3765
+ opts?: { expectedEpoch?: number },
3766
+ ): Promise<number> {
399
3767
  if (!dstId || !/^[\w.-]{1,64}$/.test(dstId)) throw new Error("invalid branch session id")
400
3768
  const db = open(cwd)
401
3769
  const now = Date.now()
402
3770
  let copied = 0
403
3771
  const txn = db.transaction(() => {
3772
+ if (opts?.expectedEpoch !== undefined) assertWriterEpochInTxn(db, dstId, opts.expectedEpoch)
404
3773
  const src = db.prepare("SELECT cwd, system FROM sessions WHERE id = ?").get(srcId) as {
405
3774
  cwd: string
406
3775
  system: string
@@ -409,9 +3778,20 @@ export async function branchSession(srcId: string, dstId: string, cwd?: string):
409
3778
  db.prepare(
410
3779
  "INSERT OR REPLACE INTO sessions (id, created_at, updated_at, cwd, system) VALUES (?, ?, ?, ?, ?)",
411
3780
  ).run(dstId, now, now, src.cwd, src.system)
3781
+ // P2.2: cabang = garis otoritas BARU. Epoch sumber tak diwarisi (0):
3782
+ // penulis cabang mulai dari generasi awal domainnya sendiri.
3783
+ db.prepare("UPDATE sessions SET writer_epoch = 0, updated_at = ? WHERE id = ?").run(now, dstId)
3784
+ // P2.4: baris default Thread dst (komposit dst/th_default) + pointer.
3785
+ db.prepare(
3786
+ "INSERT OR IGNORE INTO threads (session_id, thread_id, parent_thread_id, fork_event_seq, head_seq, status, read_only, created_at) VALUES (?, ?, NULL, NULL, -1, 'active', 0, ?)",
3787
+ ).run(dstId, DEFAULT_THREAD_ID, now)
3788
+ db.prepare("UPDATE sessions SET default_thread_id = ? WHERE id = ?").run(
3789
+ DEFAULT_THREAD_ID,
3790
+ dstId,
3791
+ )
412
3792
  const rows = db
413
3793
  .prepare(
414
- "SELECT seq, role, content, toolCalls, toolCallId, name, ts FROM messages WHERE session_id = ? ORDER BY seq",
3794
+ "SELECT seq, role, content, toolCalls, toolCallId, name, reasoning, is_error, ts, thread_id, event_id, run_id, migrated, migrated_compacted, projection_note FROM messages WHERE session_id = ? ORDER BY seq",
415
3795
  )
416
3796
  .all(srcId) as {
417
3797
  seq: number
@@ -420,15 +3800,53 @@ export async function branchSession(srcId: string, dstId: string, cwd?: string):
420
3800
  toolCalls: string
421
3801
  toolCallId: string | null
422
3802
  name: string | null
3803
+ reasoning: string | null
3804
+ is_error: number | null
423
3805
  ts: number
3806
+ thread_id: string | null
3807
+ event_id: string | null
3808
+ run_id: string | null
3809
+ migrated: number
3810
+ migrated_compacted: number
3811
+ projection_note: string | null
424
3812
  }[]
425
3813
  const ins = db.prepare(
426
- "INSERT INTO messages (session_id, seq, role, content, toolCalls, toolCallId, name, ts) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
3814
+ "INSERT INTO messages (session_id, thread_id, seq, role, content, toolCalls, toolCallId, name, reasoning, is_error, ts, event_id, run_id, migrated, migrated_compacted, projection_note) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
427
3815
  )
428
3816
  for (const r of rows) {
429
- ins.run(dstId, r.seq, r.role, r.content, r.toolCalls, r.toolCallId, r.name, r.ts)
3817
+ ins.run(
3818
+ dstId,
3819
+ r.thread_id ?? DEFAULT_THREAD_ID,
3820
+ r.seq,
3821
+ r.role,
3822
+ r.content,
3823
+ r.toolCalls,
3824
+ r.toolCallId,
3825
+ r.name,
3826
+ r.reasoning,
3827
+ r.is_error,
3828
+ r.ts,
3829
+ r.event_id,
3830
+ // P2.6: run_id TIDAK diwarisi. Baris run milik sesi sumber; menyalin
3831
+ // id-nya di dst = Lien Run Palsu (menunjuk run yang tak ada di dst).
3832
+ // EventId tetap dipertahankan (id event global, bukan milik run).
3833
+ null,
3834
+ r.migrated,
3835
+ r.migrated_compacted,
3836
+ r.projection_note,
3837
+ )
430
3838
  }
431
3839
  copied = rows.length
3840
+ // P2.4: baris Thread ikut disalin (identitas komposit membuat lineage
3841
+ // menunjuk dalam-dst secara otomatis; read_only warisan tetap; tanpa
3842
+ // traversal/merge — data saja). Head dihitung ulang per thread.
3843
+ db.prepare(
3844
+ "INSERT OR IGNORE INTO threads (session_id, thread_id, parent_thread_id, fork_event_seq, head_seq, status, read_only, created_at) SELECT ?, thread_id, parent_thread_id, fork_event_seq, head_seq, status, read_only, created_at FROM threads WHERE session_id = ?",
3845
+ ).run(dstId, srcId)
3846
+ const dstThreads = db
3847
+ .prepare("SELECT thread_id FROM threads WHERE session_id = ?")
3848
+ .all(dstId) as { thread_id: string }[]
3849
+ for (const t of dstThreads) recomputeThreadHeadInTxn(db, dstId, t.thread_id)
432
3850
  const turns = db
433
3851
  .prepare("SELECT turn_idx, usage, ts FROM turns WHERE session_id = ? ORDER BY turn_idx")
434
3852
  .all(srcId) as { turn_idx: number; usage: string; ts: number }[]
@@ -436,6 +3854,30 @@ export async function branchSession(srcId: string, dstId: string, cwd?: string):
436
3854
  "INSERT INTO turns (session_id, turn_idx, usage, ts) VALUES (?, ?, ?, ?)",
437
3855
  )
438
3856
  for (const t of turns) insT.run(dstId, t.turn_idx, t.usage, t.ts)
3857
+ const events = db
3858
+ .prepare(
3859
+ "SELECT event_seq, type, turn_id, ts, payload FROM presentation_events WHERE session_id = ? ORDER BY event_seq",
3860
+ )
3861
+ .all(srcId) as {
3862
+ event_seq: number
3863
+ type: string
3864
+ turn_id: number
3865
+ ts: number
3866
+ payload: string
3867
+ }[]
3868
+ const insE = db.prepare(
3869
+ "INSERT OR IGNORE INTO presentation_events (session_id, event_seq, type, turn_id, ts, payload) VALUES (?, ?, ?, ?, ?, ?)",
3870
+ )
3871
+ for (const event of events) {
3872
+ insE.run(
3873
+ dstId,
3874
+ event.event_seq,
3875
+ event.type,
3876
+ event.turn_id,
3877
+ event.ts,
3878
+ rebasePresentationPayload(event.payload, srcId, dstId),
3879
+ )
3880
+ }
439
3881
  })
440
3882
  try {
441
3883
  await withBusyRetry(() => txn())