minicode-ai 0.28.0 → 0.30.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.
@@ -1,13 +1,7 @@
1
1
  import { Database } from "bun:sqlite"
2
2
  import { createHash, randomUUID } from "node:crypto"
3
3
  import { existsSync } from "node:fs"
4
- import { LIMITS } from "../constants.ts"
5
- import {
6
- isSqliteContention,
7
- resolveDbPath,
8
- resolveLocalDbPath,
9
- withSqliteBusyRetrySync,
10
- } from "../lib/db-path.ts"
4
+ import { isSqliteContention } from "../lib/db-path.ts"
11
5
  import { scrubSecrets } from "../policy/scrub.ts"
12
6
  import { type DomainEvent, DURABILITY, EVENT_SCHEMA_VERSION } from "../presentation/events.ts"
13
7
 
@@ -16,522 +10,69 @@ import { type DomainEvent, DURABILITY, EVENT_SCHEMA_VERSION } from "../presentat
16
10
  // tetapi salah untuk state per-workspace (offset konsumen & persetujuan
17
11
  // daemon): proyek A yang "melanjutkan" dari progres proyek B adalah bocoran
18
12
  // scope yang tak pernah bisa dilihat pemakai.
19
- const dbPath = (cwd?: string, local = false) =>
20
- local ? resolveLocalDbPath("sessions.db", cwd) : resolveDbPath("sessions.db", cwd)
21
-
22
- const initializedSessionPaths = new Set<string>()
23
-
24
- // [Audit #2 C.F1] Gate DDL/migrasi per path. `initializedSessionPaths` hanya
25
- // men-gate PRAGMA WAL; ~30 statement DDL (CREATE TABLE IF NOT EXISTS, PRAGMA
26
- // table_info, ALTER TABLE) TIDAK di-gate di jalur lama, sehingga dijalankan
27
- // ulang di setiap `open()` (50 call site). Set ini menandai path yang SKEMA-nya
28
- // sudah jadi, asal marker migrasi terakhir (kolom daemon_approvals.invocation_id)
29
- // masih ada di koneksi.
30
- const migratedSessionPaths = new Set<string>()
31
-
32
- /**
33
- * [Audit #2 C.F1] Cek tanda migrasi SELESAI di koneksi saat ini (bukan cache
34
- * lintas-handle). Marker = kolom `daemon_approvals.invocation_id` (kolom PALING
35
- * AKHIR yang ditambahkan migrasi). Cek KOLOM — bukan sekadar keberadaan tabel —
36
- * karena test migrasi menurunkan DB lama dengan DROP COLUMN: tabel `daemon_approvals`
37
- * tetap ada tapi kolom pengikatnya hilang, dan harus di-ALTER ulang.
38
- */
39
- function daemonApprovalsMigrated(db: Database): boolean {
40
- try {
41
- const cols = db.prepare("PRAGMA table_info(daemon_approvals)").all() as { name: string }[]
42
- if (!cols.some((c) => c.name === "invocation_id")) return false
43
- const sessCols = db.prepare("PRAGMA table_info(sessions)").all() as { name: string }[]
44
- return sessCols.some((c) => c.name === "work_mode")
45
- } catch {
46
- return false
47
- }
48
- }
49
-
50
- /**
51
- * Retry sinkron untuk blok setup schema di `open()`.
52
- *
53
- * Ditemukan oleh test baseline Phase 0: `open()` menjalankan
54
- * `CREATE TABLE IF NOT EXISTS` TANPA pagar retry, padahal `busy_timeout` sudah
55
- * diset. Akibatnya satu penulis yang lock-nya ditahan membuat PEMBUKA DB
56
- * melempar SQLITE_BUSY — dan itu terjadi SEBELUM `withBusyRetry` di
57
- * `appendPresentationEvents` sempat dipanggil. Jadi jalur retry yang ada tidak
58
- * pernah menyelamatkan operasi yang paling butuh: DB-nya sendiri belum siap.
59
- *
60
- * `withBusyRetry` (async) tidak bisa dipakai di sini karena `open()` sinkron
61
- * dan dipanggil dari jalur sinkron (`loadSession`, `listSessions`, dst).
62
- */
63
- // Konstanta retry inisialisasi DB. Naikkan dari 3 (baseline) ke 8 dengan
64
- // backoff exponential + jitter kecil agar tahan terhadap lonjakan proses
65
- // paralel di Windows/POSIX (temuan Live #1: dua CLI paralel → SQLITE_BUSY
66
- // saat `new Database(p)` + PRAGMA setup, salah satu proses gagal di
67
- // `cli/router.ts`). Backoff: 15+0, 30+j, 60+j, 120+j, 240+j, 480+j, 960+j,
68
- // 1920+j ms → total ≤ ~3,8 dtk untuk 8 percobaan, masih di bawah budget
69
- // startup. Jitter memecah sinkronisasi antar-proses yang mencoba ulang
70
- // pada waktu yang sama (thundering herd).
71
- const DB_INIT_ATTEMPTS = 8
72
-
73
- export function withBusyRetrySync<T>(fn: () => T, attempts = DB_INIT_ATTEMPTS): T | null {
74
- return withSqliteBusyRetrySync(fn, {
75
- attempts,
76
- deterministicJitter: true,
77
- onGiveUp: (last, n) => {
78
- process.stderr.write(
79
- `[warn] persistence: schema setup gave up after ${n} attempts: ${String((last as Error)?.message ?? last)}\n`,
80
- )
81
- },
82
- })
83
- }
84
-
85
- function open(cwd?: string, local = false): Database {
86
- const p = dbPath(cwd, local)
87
- // [Phase 7 / Live #1] Pembukaan koneksi + PRAGMA setup dibungkus dengan
88
- // withBusyRetrySync. Sebelumnya hanya DDL yang di-retry; `new Database(p)`
89
- // dan `PRAGMA journal_mode=WAL` bisa gagal SQLITE_BUSY saat dua proses CLI
90
- // paralel membuka DB bersamaan (race nyata saat dua proses CLI membuka DB). Dengan
91
- // membungkus seluruh urutan inisialisasi, proses yang kalah tunggu lalu
92
- // coba ulang sampai lock dilepas (backoff eksponensial + jitter, 8×).
93
- // PRAGMA busy_timeout DIATUR dalam retry yang sama SEBELUM journal_mode:
94
- // peralihan ke WAL butuh exclusive lock sesaat yang langsung gagal tanpa
95
- // busy_timeout aktif (audit #09 P1 §27).
96
- const db = withBusyRetrySync(() => {
97
- const d = new Database(p)
98
- try {
99
- d.exec(`PRAGMA busy_timeout=${LIMITS.SQLITE_BUSY_TIMEOUT_MS}`)
100
- } catch {}
101
- return d
102
- })
103
- if (!db) {
104
- throw new Error(
105
- `persistence: cannot open sessions.db after ${DB_INIT_ATTEMPTS} busy-retry attempts: ${p}`,
106
- )
107
- }
108
- // [Audit #3 RL-1] Seluruh langkah pasca-konstruksi (WAL + DDL/migrasi) dibungkus
109
- // agar kegagalan SQLITE_IOERR/CORRUPT menutup handle `Database` — bukan bocor.
110
- try {
111
- if (!initializedSessionPaths.has(p)) {
112
- // journal_size_limit + wal_autocheckpoint: WAL tidak tumbuh tak terbatas.
113
- // Bungkus try/catch DENGAN retry-next-open (audit 2026-09-16): di Windows,
114
- // lock AV/file sesaat saat dua proses membuka bersamaan membuat setup WAL
115
- // gagal SQLITE_IOERR_TRUNCATE — crash di sini mematikan SELURUH operasi
116
- // sesi padahal mode rollback-journal tetap bisa baca. Jangan tandai
117
- // initialized bila gagal agar open berikutnya mencoba lagi (mode WAL
118
- // persisten di berkas DB, jadi sekali sukses berlaku untuk semua handle).
119
- // Phase 7: PRAGMA setup ini juga dibungkus withBusyRetrySync karena
120
- // peralihan WAL butuh exclusive lock sesaat.
121
- const walOk = withBusyRetrySync(() => {
122
- db.exec(
123
- `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};`,
124
- )
125
- initializedSessionPaths.add(p)
126
- return true
127
- })
128
- if (walOk === null) {
129
- process.stderr.write(`[warn] persistence: wal setup deferred, retry next open: ${p}\n`)
130
- }
131
- // File DB dibuat dengan 644 default; ubah ke 600 agar history tidak world-readable
132
- try {
133
- const { chmodSync } = require("node:fs") as typeof import("node:fs")
134
- chmodSync(p, 0o600)
135
- // WAL/SHM akan dibuat dengan mode yang sama pada checkpoint berikutnya
136
- } catch {}
137
- }
138
- // [Audit #2 C.F1] DDL/migrasi DI-GATE per path: bila path sudah di-migrasi
139
- // DAN marker migrasi terakhir (kolom daemon_approvals.invocation_id) masih ada
140
- // di koneksi ini, lewati seluruh blok CREATE/ALTER. Cek KOLOM di koneksi saat
141
- // ini memastikan DB yang dihapus + dibuat ulang (atau kolom di-DROP oleh test
142
- // migrasi) TETAP di-migrasi ulang — Set hanya cache path, bukan handle Database.
143
- const needsDdl = !migratedSessionPaths.has(p) || !daemonApprovalsMigrated(db)
144
- if (needsDdl) {
145
- // DDL setup: `CREATE TABLE IF NOT EXISTS` butuh lock tulis bila tabel belum
146
- // ada. Tanpa retry di sini, DB yang sedang dikunci proses lain membuat
147
- // SETIAP operasi sesi gagal seketika. `null` = gagal terus; pemanggil akan
148
- // gagal di statement berikutnya dengan pesan yang lebih jelas.
149
- withBusyRetrySync(() => {
150
- db.exec(`
151
- 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, work_mode TEXT NULL);
152
- 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));
153
- CREATE TABLE IF NOT EXISTS turns (session_id TEXT, turn_idx INTEGER, usage TEXT, ts INTEGER, PRIMARY KEY(session_id, turn_idx));
154
- CREATE TABLE IF NOT EXISTS presentation_events (
155
- session_id TEXT NOT NULL,
156
- event_seq INTEGER NOT NULL,
157
- type TEXT NOT NULL,
158
- turn_id INTEGER NOT NULL,
159
- ts INTEGER NOT NULL,
160
- payload TEXT NOT NULL,
161
- PRIMARY KEY(session_id, event_seq)
162
- );
163
- CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id, seq);
164
- CREATE INDEX IF NOT EXISTS idx_presentation_events_session ON presentation_events(session_id, event_seq);
165
- `)
166
- })
167
- // migration: add updated_at, toolCallId, name jika kolom lama (backward-compat)
168
- try {
169
- const cols = db.prepare("PRAGMA table_info(sessions)").all() as { name: string }[]
170
- if (!cols.some((c) => c.name === "updated_at")) {
171
- db.exec("ALTER TABLE sessions ADD COLUMN updated_at INTEGER")
172
- db.exec("UPDATE sessions SET updated_at = created_at WHERE updated_at IS NULL")
173
- }
174
- db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC)`)
175
- // P2.9 — lineage Sub-Agent. Aditif + idempoten. NULL = sesi root (parent
176
- // ATAU anak legasi pra-P2.9). Sesi anak MEILIKI baris sessions sendiri;
177
- // ini yang menutup cacat namespace hantu (presentation_events.session_id
178
- // menunjuk id tanpa baris sessions → dihapus orphan-purge).
179
- if (!cols.some((c) => c.name === "parent_session_id")) {
180
- db.exec("ALTER TABLE sessions ADD COLUMN parent_session_id TEXT NULL")
181
- }
182
- if (!cols.some((c) => c.name === "parent_run_id")) {
183
- db.exec("ALTER TABLE sessions ADD COLUMN parent_run_id TEXT NULL")
184
- }
185
- // P0.2 (Q5): persistensi WorkMode di metadata sesi lintas `--resume`.
186
- // NULL = sesi legacy tanpa WorkMode tersimpan (resume fallback DISCUSS).
187
- if (!cols.some((c) => c.name === "work_mode")) {
188
- db.exec("ALTER TABLE sessions ADD COLUMN work_mode TEXT NULL")
189
- }
190
- db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_parent ON sessions(parent_session_id)`)
191
- } catch (e) {
192
- process.stderr.write(
193
- `[warn] persistence: sessions migration skipped: ${(e as Error).message}\n`,
194
- )
195
- }
196
- try {
197
- const msgCols = db.prepare("PRAGMA table_info(messages)").all() as { name: string }[]
198
- if (!msgCols.some((c) => c.name === "toolCallId")) {
199
- db.exec("ALTER TABLE messages ADD COLUMN toolCallId TEXT")
200
- db.exec("ALTER TABLE messages ADD COLUMN name TEXT")
201
- }
202
- // Fidelity resume: `reasoning` (thinking DeepSeek-style) dan `is_error`
203
- // (tool gagal) adalah bagian dari kernel Message dan ikut dibawa ke
204
- // history, tapi kolomnya tak pernah ada — resume lama sewajarnya buta dan
205
- // model kehilangan konteks kegagalannya. Additive, jadi DB lama tetap
206
- // terbaca dan turn lama (tanpa kolom ini) tetap resume dengan isError
207
- // diperlakukan absen.
208
- if (!msgCols.some((c) => c.name === "reasoning")) {
209
- db.exec("ALTER TABLE messages ADD COLUMN reasoning TEXT")
210
- }
211
- if (!msgCols.some((c) => c.name === "is_error")) {
212
- db.exec("ALTER TABLE messages ADD COLUMN is_error INTEGER")
213
- }
214
- } catch (e) {
215
- process.stderr.write(
216
- `[warn] persistence: messages migration skipped: ${(e as Error).message}\n`,
217
- )
218
- }
219
- // P2.1 — peta alias identitas sesi: alias (input mentah eksak) → kanonik.
220
- // Additive: DB lama mendapat tabel kosong; tak ada baris lama yang berubah.
221
- // `alias` = input mentah persis (bukan hasil sanitasi) agar tabrakan
222
- // sanitizer (`a/b` vs `a-b`) tetap terbedakan; `fs_key` = bentuk kanonik
223
- // untuk deteksi tabrakan kunci filesystem.
224
- withBusyRetrySync(() => {
225
- db.exec(`
226
- 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);
227
- CREATE INDEX IF NOT EXISTS idx_session_aliases_fs ON session_aliases(fs_key);
228
- CREATE INDEX IF NOT EXISTS idx_session_aliases_canonical ON session_aliases(canonical);
229
- `)
230
- })
231
- // P2.2 — pagar penulis (writer fence): generasi otoritas penulis dalam
232
- // satu generasi identitas sesi. BEDA dari inkarnasi TaskStore (generasi
233
- // identitas lintas delete/recreate): epoch hanya maju lewat takeover dan
234
- // tak pernah diubah save biasa. Baris lama → 0 (deterministik).
235
- // P2.3 — slot default_thread_id (nullable transisional; P2.4 menegakkan
236
- // invariant) + kolom dorman messages (NULL/0 = legacy tak-berskala;
237
- // P2.4 backfill, P2.5 alokator + UNIQUE event_id via index).
238
- try {
239
- const sessCols = db.prepare("PRAGMA table_info(sessions)").all() as { name: string }[]
240
- if (!sessCols.some((c) => c.name === "writer_epoch")) {
241
- db.exec("ALTER TABLE sessions ADD COLUMN writer_epoch INTEGER NOT NULL DEFAULT 0")
242
- }
243
- if (!sessCols.some((c) => c.name === "default_thread_id")) {
244
- db.exec("ALTER TABLE sessions ADD COLUMN default_thread_id TEXT NULL")
245
- }
246
- const msgCols2 = db.prepare("PRAGMA table_info(messages)").all() as { name: string }[]
247
- const addMsgCol = (name: string, ddl: string): void => {
248
- if (!msgCols2.some((c) => c.name === name))
249
- db.exec(`ALTER TABLE messages ADD COLUMN ${ddl}`)
250
- }
251
- addMsgCol("thread_id", "thread_id TEXT NULL")
252
- addMsgCol("event_id", "event_id TEXT NULL")
253
- addMsgCol("run_id", "run_id TEXT NULL")
254
- addMsgCol("migrated", "migrated INTEGER NOT NULL DEFAULT 0")
255
- addMsgCol("migrated_compacted", "migrated_compacted INTEGER NOT NULL DEFAULT 0")
256
- addMsgCol("projection_note", "projection_note TEXT NULL")
257
- // P2.6: takeover_epoch untuk runs (NULL = pra-P2.6; diisi saat create).
258
- try {
259
- const runCols = db.prepare("PRAGMA table_info(runs)").all() as { name: string }[]
260
- if (runCols.length > 0 && !runCols.some((c) => c.name === "takeover_epoch")) {
261
- db.exec("ALTER TABLE runs ADD COLUMN takeover_epoch INTEGER NULL")
262
- }
263
- } catch {
264
- // Tabel absen (handle mentah) atau gagal — CREATE di atas yang berlaku.
265
- }
266
- // P2.7: anchor_event_id untuk history_projections (NULL = pra-P2.7 atau
267
- // cakupan kosong; diisi saat build bila base_seq > 0). Aditif idempoten
268
- // seperti kolom di atas; baris lama (bila ada) dipertahankan utuh.
269
- try {
270
- const projCols = db.prepare("PRAGMA table_info(history_projections)").all() as {
271
- name: string
272
- }[]
273
- if (projCols.length > 0 && !projCols.some((c) => c.name === "anchor_event_id")) {
274
- db.exec("ALTER TABLE history_projections ADD COLUMN anchor_event_id TEXT NULL")
275
- }
276
- } catch {
277
- // Tabel absen atau gagal — CREATE di bawah yang berlaku.
278
- }
279
- // Indeks di SINI (setelah ALTER): CREATE INDEX atas kolom yang belum ada
280
- // melempar di DB legacy bila dikerjakan sebelum migrasi kolom (temuan
281
- // P2.3: open() gagal total). Idempoten seperti indeks lain di atas.
282
- // P2.4 — identitas histori kanonik (session_id, thread_id, seq): UNIQUE
283
- // (menggantikan idx_messages_thread P2.3 yang salah-bentuk tanpa
284
- // session_id). NULL thread legacy dikecualikan SQLite secara alami.
285
- // P2.5 — keunikan event: UNIQUE(session_id, thread_id, event_id).
286
- // NULL dikecualikan (baris legacy pra-backfill tak pernah konflik);
287
- // komposit (bukan global) agar branch PRESERVE event_id tetap konsisten
288
- // (masa lalu bersama = id sama di sesi berbeda — analogi objek git).
289
- db.exec("DROP INDEX IF EXISTS idx_messages_thread")
290
- withBusyRetrySync(() => {
291
- db.exec(`
292
- CREATE UNIQUE INDEX IF NOT EXISTS udx_messages_thread_seq ON messages(session_id, thread_id, seq);
293
- CREATE UNIQUE INDEX IF NOT EXISTS udx_messages_event_id ON messages(session_id, thread_id, event_id);
294
- CREATE INDEX IF NOT EXISTS idx_messages_run ON messages(run_id);
295
- `)
296
- })
297
- } catch (e) {
298
- process.stderr.write(
299
- `[warn] persistence: writer_epoch migration skipped: ${(e as Error).message}\n`,
300
- )
301
- }
302
- // P2.2 — rekaman takeover durable: SATU baris per (sesi, prior_epoch).
303
- // Keunikan inilah yang membuat takeover simultan punya tepat satu pemenang
304
- // (tanpa mengandalkan Date.now): pecundang menabrak constraint dan
305
- // mengamati hasil pemenang (idempoten), bukan menaikkan epoch lagi.
306
- withBusyRetrySync(() => {
307
- db.exec(`
308
- 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));
309
- CREATE INDEX IF NOT EXISTS idx_session_takeovers_session ON session_takeovers(session_id);
310
- `)
311
- })
312
- // P2.3 — kerangka penyimpanan (STORAGE ONLY, tanpa semantik aktif).
313
- // Ketiga tabel + kolom dorman di bawah TIDAK ditulis/dibaca runtime mana
314
- // pun di fase ini; P2.4 (Thread), P2.5 (Run/kursor), P2.7 (proyeksi) yang
315
- // mengaktifkannya. Konvensi migrasi = DDL idempoten di open() (tanpa
316
- // user_version: semua perubahan aditif; restart-safe via idempotence,
317
- // bukan via atomisitas DDL — SQLite men-commit tiap statement).
318
- // P2.4 — koreksi identitas Thread: komposit (session_id, thread_id).
319
- // Skema P2.3 memakai thread_id PK global (satu 'th_default' sedunia —
320
- // mustahil). Identitas kanonik menurut blueprint adalah pasangan
321
- // (session, thread); runs/projections sudah membawa session_id. Rebuild
322
- // HANYA bila bentuk lama terdeteksi (di bawah); AMAN karena tabel P2.3
323
- // dijamin kosong (guard netralitas + assert menolak bila ada baris —
324
- // tak pernah hapus data). Open berulang pada bentuk baru = no-op.
325
- if (threadsTableNeedsP24Rebuild(db)) {
326
- assertEmptyTableForRebuild(db, "threads")
327
- db.exec("DROP TABLE IF EXISTS threads")
328
- }
329
- if (projectionsTableNeedsP24Rebuild(db)) {
330
- assertEmptyTableForRebuild(db, "history_projections")
331
- db.exec("DROP TABLE IF EXISTS history_projections")
332
- }
333
- withBusyRetrySync(() => {
334
- db.exec(`
335
- 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));
336
- CREATE INDEX IF NOT EXISTS idx_threads_session ON threads(session_id);
337
- 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));
338
- CREATE INDEX IF NOT EXISTS idx_runs_session ON runs(session_id, started_at);
339
- CREATE INDEX IF NOT EXISTS idx_runs_thread ON runs(thread_id, started_at);
340
- -- P2.6: ≤1 RUNNING per SESSION (partial unique index = DB-enforced,
341
- -- TOCTOU-safe; pelumba kedua gagal constraint, bukan tayang ganda).
342
- CREATE UNIQUE INDEX IF NOT EXISTS udx_runs_single_running ON runs(session_id) WHERE status = 'RUNNING';
343
- 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));
344
- CREATE INDEX IF NOT EXISTS idx_projections_thread ON history_projections(session_id, thread_id);
345
- `)
346
- })
347
- // P2.12 — dua tabel milik daemon, DDL di sini karena `open()` SATU-SATUNYA
348
- // pemilik skema (setiap jalur buka DB melewati retry yang sama; DDL terpisah
349
- // di modul lain = dua jalur setup yang bisa berbeda urutan lock-nya).
350
- //
351
- // consumer_offsets: offset terakhir yang DIACK konsumen. TERPISAH dari
352
- // `runs.last_persisted_seq` (watermark penulis), `writer_epoch` (pagar
353
- // mutasi), dan `presentation_events.event_seq` (kepala kanonik) — empat
354
- // angka yang sering tertukar; kontrak melarang menggabungkannya karena
355
- // offset konsumen = "sudah diproses", bukan "sudah ditulis"/"punya siapa".
356
- //
357
- // daemon_approvals: mesin persetujuan durable. `state` dkk. — UI hanya
358
- // MENGUSULKAN keputusan; baris ini adalah otoritasnya.
359
- withBusyRetrySync(() => {
360
- db.exec(`
361
- CREATE TABLE IF NOT EXISTS consumer_offsets (
362
- consumer_id TEXT NOT NULL,
363
- session_id TEXT NOT NULL,
364
- last_acked_seq INTEGER NOT NULL DEFAULT -1,
365
- updated_at INTEGER NOT NULL,
366
- PRIMARY KEY(consumer_id, session_id),
367
- CHECK(last_acked_seq >= -1)
368
- );
369
- CREATE INDEX IF NOT EXISTS idx_consumer_offsets_session ON consumer_offsets(session_id);
370
- CREATE TABLE IF NOT EXISTS daemon_approvals (
371
- approval_id TEXT PRIMARY KEY,
372
- session_id TEXT NOT NULL,
373
- run_id TEXT NULL,
374
- tool TEXT NOT NULL,
375
- summary TEXT NOT NULL DEFAULT '',
376
- state TEXT NOT NULL,
377
- requested_at INTEGER NOT NULL,
378
- expires_at INTEGER NULL,
379
- decided_at INTEGER NULL,
380
- decision TEXT NULL,
381
- incarnation TEXT NOT NULL,
382
- args_hash TEXT NULL,
383
- invocation_id TEXT NULL
384
- );
385
- CREATE INDEX IF NOT EXISTS idx_daemon_approvals_session ON daemon_approvals(session_id, requested_at);
386
- CREATE INDEX IF NOT EXISTS idx_daemon_approvals_state ON daemon_approvals(state);
387
- `)
388
- })
389
- // [Fase 2 / LOOP-INV-08] Migrasi aditif untuk DB lama: kolom pengikat
390
- // approval. `PRAGMA table_info` + `ALTER TABLE` idempoten, tanpa
391
- // user_version (konvensi yang sama dengan migrasi lain di file ini).
392
- // Baris lama mendapat NULL = "tanpa pengikat" dan tetap terbaca; validasi
393
- // pengikatan memperlakukan NULL sebagai tidak cocok bila sisi eksekusi
394
- // membawa hash (fail-closed), bukan sebagai izin.
395
- try {
396
- const approvalCols = db.prepare("PRAGMA table_info(daemon_approvals)").all() as {
397
- name: string
398
- }[]
399
- if (!approvalCols.some((c) => c.name === "args_hash")) {
400
- db.exec("ALTER TABLE daemon_approvals ADD COLUMN args_hash TEXT NULL")
401
- }
402
- if (!approvalCols.some((c) => c.name === "invocation_id")) {
403
- db.exec("ALTER TABLE daemon_approvals ADD COLUMN invocation_id TEXT NULL")
404
- }
405
- } catch (e) {
406
- process.stderr.write(
407
- `[warn] persistence: daemon_approvals migration skipped: ${(e as Error).message}\n`,
408
- )
409
- }
410
- migratedSessionPaths.add(p)
411
- }
412
- return db
413
- } catch (err) {
414
- try {
415
- db.close()
416
- } catch {}
417
- throw err
418
- }
419
- }
420
-
421
- // P2.12 — gerbang terbuka untuk pemilik skema lain (toko konsumen/persetujuan
422
- // daemon) yang butuh handle lengkap: WAL + busy_timeout + DDL yang sama.
423
- // Sengaja diekspos sebagai fungsi, bukan `open` sendiri, agar setiap pemanggil
424
- // tetap melewati satu jalur setup yang sama.
425
- export function openSessionDb(cwd?: string): Database {
426
- return open(cwd)
427
- }
428
-
429
- // P2.12 — sessions.db milik SATU workspace. Beda dari `openSessionDb` di atas:
430
- // tak pernah jatuh ke `~/.minicode` global. Dipakai toko daemon (offset
431
- // konsumen + persetujuan) karena keduanya menyatakan keadaan SATU workspace;
432
- // menjatuhkannya ke DB bersama membuat konsumen workspace lain "melanjutkan"
433
- // dari progres yang bukan miliknya — dan tak ada yang bisa membedakannya.
434
- export function openWorkspaceSessionDb(cwd?: string): Database {
435
- return open(cwd, true)
436
- }
437
-
438
- // P2.2 — penolakan penulis basi. BEDA dari SQLITE_BUSY (masih boleh retry):
439
- // epoch tak cocok = otoritas telah pindah; retry buta hanya menimpa penulis
440
- // baru. Pemanggil wajib fail-closed (diagnostik eksplisit), bukan retry.
441
- export class StaleWriterError extends Error {
442
- readonly code = "REFUSED_STALE_EPOCH"
443
- readonly sessionId: string
444
- readonly expectedEpoch: number
445
- readonly actualEpoch: number
446
- constructor(sessionId: string, expectedEpoch: number, actualEpoch: number) {
447
- super(
448
- `[persist] REFUSED_STALE_EPOCH sid=${sessionId} expected=${expectedEpoch} actual=${actualEpoch} — authority moved; history NOT durable`,
449
- )
450
- this.name = "StaleWriterError"
451
- this.sessionId = sessionId
452
- this.expectedEpoch = expectedEpoch
453
- this.actualEpoch = actualEpoch
454
- }
455
- }
456
-
457
- // P2.2 — baca pagar generasi penulis (0 bila baris belum ada: nilai awal
458
- // deterministik untuk sesi yang belum pernah persist).
459
- export function readWriterEpoch(id: string, cwd?: string): number {
460
- const db = open(cwd)
461
- try {
462
- const row = db.prepare("SELECT writer_epoch AS epoch FROM sessions WHERE id = ?").get(id) as {
463
- epoch: number | null
464
- } | null
465
- return row?.epoch ?? 0
466
- } finally {
467
- db.close()
468
- }
469
- }
470
-
471
- // Verifikasi pagar DI DALAM transaksi pemanggil. Melempar StaleWriterError
472
- // (rollback oleh txn) bila: baris tak ada padahal ekspektasi > 0 (dunia
473
- // bergerak: sesi dihapus/dibuat ulang), atau epoch tak cocok.
474
- function assertWriterEpochInTxn(db: Database, id: string, expectedEpoch: number): void {
475
- const row = db.prepare("SELECT writer_epoch AS epoch FROM sessions WHERE id = ?").get(id) as {
476
- epoch: number | null
477
- } | null
478
- const actual = row?.epoch ?? 0
479
- if (row !== null && actual !== expectedEpoch) {
480
- throw new StaleWriterError(id, expectedEpoch, actual)
481
- }
482
- if (row === null && expectedEpoch !== 0) {
483
- throw new StaleWriterError(id, expectedEpoch, actual)
484
- }
485
- }
486
- // array ribuan angka — cukup placeholder agar DB tidak menggembung.
487
- // Bentuk lama P2.3 terdeteksi dari PK: [thread_id] saja (threads) atau
488
- // absennya kolom session_id (history_projections). Bentuk baru / tak-ada
489
- // tabel → false (CREATE IF NOT EXISTS cukup).
490
- function threadsTableNeedsP24Rebuild(db: Database): boolean {
491
- try {
492
- const cols = db.prepare("PRAGMA table_info(threads)").all() as { name: string; pk: number }[]
493
- if (cols.length === 0) return false
494
- const pk = cols
495
- .filter((c) => c.pk > 0)
496
- .sort((a, b) => a.pk - b.pk)
497
- .map((c) => c.name)
498
- return !(pk.length === 2 && pk[0] === "session_id" && pk[1] === "thread_id")
499
- } catch {
500
- return false
501
- }
502
- }
503
-
504
- function projectionsTableNeedsP24Rebuild(db: Database): boolean {
505
- try {
506
- const cols = db.prepare("PRAGMA table_info(history_projections)").all() as { name: string }[]
507
- if (cols.length === 0) return false
508
- return !cols.some((c) => c.name === "session_id")
509
- } catch {
510
- return false
511
- }
512
- }
513
-
514
- // P2.4 — penolak rebuild destruktif. Dipakai HANYA untuk tabel kerangka
515
- // P2.3 yang dijamin kosong (netralitas runtime + guard): bila ada baris,
516
- // rebuild DITOLAK loud (tak pernah hapus data diam-diam). Tabel tak-ada =
517
- // aman (belum pernah dibuat).
518
- function assertEmptyTableForRebuild(db: Database, table: string): void {
519
- let exists = false
520
- try {
521
- const row = db
522
- .prepare("SELECT 1 AS ok FROM sqlite_master WHERE type = 'table' AND name = ?")
523
- .get(table) as { ok: number } | null
524
- exists = row !== null
525
- } catch {
526
- return
527
- }
528
- if (!exists) return
529
- const n = (db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get() as { n: number }).n
530
- if (n > 0) {
531
- throw new Error(
532
- `[persistence] refusing to rebuild non-empty table ${table} (${n} rows) — migrate, never destroy`,
533
- )
534
- }
13
+ import {
14
+ advanceRunCursor,
15
+ advanceRunCursorInTxn,
16
+ allocateRunId,
17
+ assessRunRecoveryStatus,
18
+ completeRun,
19
+ createRun,
20
+ failRun,
21
+ getActiveRun,
22
+ getRun,
23
+ interruptRun,
24
+ isRunId,
25
+ listSessionRuns,
26
+ RUN_TERMINAL,
27
+ RunCursorError,
28
+ RunPendingError,
29
+ type RunRow,
30
+ RunRunningExistsError,
31
+ type RunStatus,
32
+ RunStatusError,
33
+ RunTerminalConflictError,
34
+ setRunPendingTools,
35
+ tombstoneDeadRuns,
36
+ transitionRun,
37
+ } from "./db/runs.ts"
38
+ import {
39
+ assertWriterEpochInTxn,
40
+ dbPath,
41
+ openSessionHandle as open,
42
+ openSessionDb,
43
+ openWorkspaceSessionDb,
44
+ readWriterEpoch,
45
+ StaleWriterError,
46
+ sessionRowExistsInTxn,
47
+ withBusyRetrySync,
48
+ } from "./db/schema.ts"
49
+
50
+ export type { RunRow, RunStatus }
51
+ export {
52
+ advanceRunCursor,
53
+ allocateRunId,
54
+ assessRunRecoveryStatus,
55
+ completeRun,
56
+ createRun,
57
+ failRun,
58
+ getActiveRun,
59
+ getRun,
60
+ interruptRun,
61
+ isRunId,
62
+ listSessionRuns,
63
+ openSessionDb,
64
+ openWorkspaceSessionDb,
65
+ RunCursorError,
66
+ RunPendingError,
67
+ RunRunningExistsError,
68
+ RunStatusError,
69
+ RunTerminalConflictError,
70
+ readWriterEpoch,
71
+ StaleWriterError,
72
+ setRunPendingTools,
73
+ tombstoneDeadRuns,
74
+ transitionRun,
75
+ withBusyRetrySync,
535
76
  }
536
77
 
537
78
  // JSON-safe serialization: konten binary (Uint8Array) jangan di-stringify jadi
@@ -2832,438 +2373,6 @@ export function appendHistoryEvent(
2832
2373
  // persistensi, bukan token/usaha). ≤1 RUNNING per SESSION ditegakkan
2833
2374
  // partial-unique-index (ras-aman, tanpa TOCTOU). Semua mutasi berpagar epoch.
2834
2375
 
2835
- export type RunStatus = "CREATED" | "RUNNING" | "COMPLETED" | "INTERRUPTED" | "FAILED"
2836
-
2837
- const RUN_TERMINAL: ReadonlySet<string> = new Set(["COMPLETED", "INTERRUPTED", "FAILED"])
2838
-
2839
- export interface RunRow {
2840
- run_id: string
2841
- session_id: string
2842
- thread_id: string
2843
- status: RunStatus
2844
- started_at: number
2845
- ended_at: number | null
2846
- last_persisted_seq: number
2847
- pending_tool_ids: string
2848
- recovery_status: string | null
2849
- takeover_epoch: number | null
2850
- created_at: number
2851
- }
2852
-
2853
- 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}$/
2854
-
2855
- export function isRunId(value: unknown): value is string {
2856
- return typeof value === "string" && RUN_ID_RE.test(value)
2857
- }
2858
-
2859
- // SATU-SATUNYA allocator RunId produksi (CSPRNG; domain sesi, berbeda dari
2860
- // exec_/dsp_/attempt — lihat keputusan §6 laporan: tak ada reuse).
2861
- export function allocateRunId(): string {
2862
- return `run_${randomUUID()}`
2863
- }
2864
-
2865
- export class RunStatusError extends Error {
2866
- readonly code = "RUN_INVALID_TRANSITION"
2867
- constructor(runId: string, from: string, to: string) {
2868
- super(`[run] RUN_INVALID_TRANSITION ${runId}: ${from} → ${to} refused`)
2869
- this.name = "RunStatusError"
2870
- }
2871
- }
2872
-
2873
- export class RunTerminalConflictError extends Error {
2874
- readonly code = "RUN_TERMINAL_CONFLICT"
2875
- constructor(runId: string, from: string, to: string) {
2876
- super(
2877
- `[run] RUN_TERMINAL_CONFLICT ${runId}: already terminal ${from}, refusing conflicting ${to} (first terminal wins)`,
2878
- )
2879
- this.name = "RunTerminalConflictError"
2880
- }
2881
- }
2882
-
2883
- export class RunRunningExistsError extends Error {
2884
- readonly code = "RUNNING_EXISTS"
2885
- constructor(sessionId: string) {
2886
- super(`[run] RUNNING_EXISTS ${sessionId}: a RUNNING run already holds this session`)
2887
- this.name = "RunRunningExistsError"
2888
- }
2889
- }
2890
-
2891
- export class RunCursorError extends Error {
2892
- readonly code: "RUN_CURSOR_BACKWARD" | "RUN_CURSOR_BEYOND_HEAD" | "RUN_CURSOR_FOREIGN"
2893
- constructor(code: RunCursorError["code"], runId: string, detail: string) {
2894
- super(`[run] ${code} ${runId}: ${detail}`)
2895
- this.name = "RunCursorError"
2896
- this.code = code
2897
- }
2898
- }
2899
-
2900
- export class RunPendingError extends Error {
2901
- readonly code = "RUN_PENDING_MALFORMED"
2902
- constructor(detail: string) {
2903
- super(`[run] RUN_PENDING_MALFORMED: ${detail}`)
2904
- this.name = "RunPendingError"
2905
- }
2906
- }
2907
-
2908
- function rowToRun(row: RunRow): RunRow {
2909
- return { ...row }
2910
- }
2911
-
2912
- const RUN_COLUMNS =
2913
- "run_id, session_id, thread_id, status, started_at, ended_at, last_persisted_seq, pending_tool_ids, recovery_status, takeover_epoch, created_at"
2914
-
2915
- export function getRun(runId: string, cwd?: string): RunRow | null {
2916
- const db = open(cwd)
2917
- try {
2918
- const row = db
2919
- .prepare(`SELECT ${RUN_COLUMNS} FROM runs WHERE run_id = ?`)
2920
- .get(runId) as RunRow | null
2921
- return row ? rowToRun(row) : null
2922
- } finally {
2923
- db.close()
2924
- }
2925
- }
2926
-
2927
- export function listSessionRuns(sessionId: string, cwd?: string): RunRow[] {
2928
- const db = open(cwd)
2929
- try {
2930
- return (
2931
- db
2932
- .prepare(`SELECT ${RUN_COLUMNS} FROM runs WHERE session_id = ? ORDER BY started_at`)
2933
- .all(sessionId) as RunRow[]
2934
- ).map(rowToRun)
2935
- } finally {
2936
- db.close()
2937
- }
2938
- }
2939
-
2940
- // RUNNING aktif sesi ini (0-atau-1 menurut partial index; defensif LIMIT 1).
2941
- export function getActiveRun(sessionId: string, cwd?: string): RunRow | null {
2942
- const db = open(cwd)
2943
- try {
2944
- const row = db
2945
- .prepare(
2946
- `SELECT ${RUN_COLUMNS} FROM runs WHERE session_id = ? AND status = 'RUNNING' LIMIT 1`,
2947
- )
2948
- .get(sessionId) as RunRow | null
2949
- return row ? rowToRun(row) : null
2950
- } finally {
2951
- db.close()
2952
- }
2953
- }
2954
-
2955
- // Penilaian pulih read-only (tak pernah memutasi): ketidakpastian TERSIMPAN
2956
- // (recovery_status UNKNOWN) atau RUNNING tanpa holder hidup = UNKNOWN;
2957
- // sisanya NONE. Persistensi resolusi milik fase mendatang; P2.6 hanya
2958
- // menombak yang mati pasti + menilainya jujur.
2959
- export function assessRunRecoveryStatus(run: RunRow): "NONE" | "UNKNOWN" {
2960
- if (run.recovery_status === "UNKNOWN") return "UNKNOWN"
2961
- if (run.status === "RUNNING") return "UNKNOWN"
2962
- return "NONE"
2963
- }
2964
-
2965
- function validatePendingToolIds(value: unknown): string {
2966
- if (!Array.isArray(value)) throw new RunPendingError("pending_tool_ids must be an array")
2967
- if (value.length > 256) throw new RunPendingError("pending_tool_ids exceeds 256 entries")
2968
- for (const entry of value) {
2969
- if (typeof entry !== "string" || entry.length === 0 || entry.length > 512) {
2970
- throw new RunPendingError("pending_tool_ids entries must be non-empty strings ≤512 chars")
2971
- }
2972
- }
2973
- return JSON.stringify(value)
2974
- }
2975
-
2976
- // Satu jalur create produksi: validasi kepemilikan (thread milik sesi) +
2977
- // pagar epoch + baris CREATED (kursor = head saat ini, netral) + epoch
2978
- // takeover tercatat. Status awal SELALU CREATED; pemanggil yang
2979
- // mempromosikan ke RUNNING via transitionRun (dua langkah eksplisit).
2980
- export function createRun(
2981
- sessionId: string,
2982
- threadId: string,
2983
- cwd?: string,
2984
- opts?: { runId?: string; pendingToolIds?: unknown; expectedEpoch?: number },
2985
- ): RunRow {
2986
- const db = open(cwd)
2987
- try {
2988
- return db.transaction(() => {
2989
- if (opts?.expectedEpoch !== undefined)
2990
- assertWriterEpochInTxn(db, sessionId, opts.expectedEpoch)
2991
- if (!sessionRowExistsInTxn(db, sessionId)) throw new Error(`session not found: ${sessionId}`)
2992
- const thread = db
2993
- .prepare("SELECT thread_id FROM threads WHERE session_id = ? AND thread_id = ?")
2994
- .get(sessionId, threadId) as { thread_id: string } | null
2995
- if (!thread) throw new Error(`thread not found: ${sessionId}/${threadId}`)
2996
- const runId = opts?.runId ?? allocateRunId()
2997
- if (!isRunId(runId)) throw new Error(`invalid run id: ${opts?.runId}`)
2998
- const pending =
2999
- opts?.pendingToolIds !== undefined ? validatePendingToolIds(opts.pendingToolIds) : "[]"
3000
- const now = Date.now()
3001
- const headRow = db
3002
- .prepare("SELECT MAX(seq) AS m FROM messages WHERE session_id = ? AND thread_id = ?")
3003
- .get(sessionId, threadId) as { m: number | null } | null
3004
- // Head thread kosong = -1, tapi kursor run punya CHECK >= 0 dan harus
3005
- // menunjuk posisi histori yang benar-benar durable: kursor awal 0 pada
3006
- // thread kosong berarti "belum ada event milik run ini" (bukan klaim
3007
- // bahwa seq 0 milik run ini — kepemilikan dicek saat advance).
3008
- const head = Math.max(headRow?.m ?? -1, 0)
3009
- const epochRow = db
3010
- .prepare("SELECT writer_epoch AS epoch FROM sessions WHERE id = ?")
3011
- .get(sessionId) as {
3012
- epoch: number
3013
- }
3014
- db.prepare(
3015
- "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', ?, ?)",
3016
- ).run(runId, sessionId, threadId, now, head, pending, epochRow.epoch, now)
3017
- return rowToRun({
3018
- run_id: runId,
3019
- session_id: sessionId,
3020
- thread_id: threadId,
3021
- status: "CREATED",
3022
- started_at: now,
3023
- ended_at: null,
3024
- last_persisted_seq: head,
3025
- pending_tool_ids: pending,
3026
- recovery_status: "NONE",
3027
- takeover_epoch: epochRow.epoch,
3028
- created_at: now,
3029
- })
3030
- })()
3031
- } finally {
3032
- db.close()
3033
- }
3034
- }
3035
-
3036
- function sessionRowExistsInTxn(db: Database, sessionId: string): boolean {
3037
- const row = db.prepare("SELECT 1 AS ok FROM sessions WHERE id = ?").get(sessionId) as {
3038
- ok: number
3039
- } | null
3040
- return row !== null
3041
- }
3042
-
3043
- const RUN_EDGES: Record<RunStatus, readonly RunStatus[]> = {
3044
- CREATED: ["RUNNING", "COMPLETED", "INTERRUPTED", "FAILED"],
3045
- RUNNING: ["COMPLETED", "INTERRUPTED", "FAILED"],
3046
- COMPLETED: ["COMPLETED"],
3047
- INTERRUPTED: ["INTERRUPTED"],
3048
- FAILED: ["FAILED"],
3049
- }
3050
-
3051
- // Transisi status fenced. Terminal→sama = idempoten (ended_at pertama menang);
3052
- // terminal→beda = konflik (first terminal wins, bukan last-writer-wins).
3053
- // RUNNING kedua konkuren = constraint partial-index → RUNNING_EXISTS terstruktur.
3054
- export function transitionRun(
3055
- runId: string,
3056
- to: RunStatus,
3057
- cwd?: string,
3058
- opts?: { expectedEpoch?: number; recoveryStatus?: string },
3059
- ): RunRow {
3060
- const db = open(cwd)
3061
- try {
3062
- return db.transaction(() => {
3063
- const row = db
3064
- .prepare(`SELECT ${RUN_COLUMNS} FROM runs WHERE run_id = ?`)
3065
- .get(runId) as RunRow | null
3066
- if (!row) throw new Error(`run not found: ${runId}`)
3067
- if (opts?.expectedEpoch !== undefined)
3068
- assertWriterEpochInTxn(db, row.session_id, opts.expectedEpoch)
3069
- // Terminal: dua kelas penolakan dibedakan agar diagnosis jujur —
3070
- // terminal→terminal lain = konflik first-wins; terminal→non-terminal
3071
- // = tepi ilegal (bukan "konflik" — tak ada klaim terminal kedua).
3072
- if (RUN_TERMINAL.has(row.status)) {
3073
- if (row.status === to) return rowToRun(row)
3074
- if (RUN_TERMINAL.has(to)) throw new RunTerminalConflictError(runId, row.status, to)
3075
- throw new RunStatusError(runId, row.status, to)
3076
- }
3077
- if (!RUN_EDGES[row.status].includes(to)) throw new RunStatusError(runId, row.status, to)
3078
- const now = Date.now()
3079
- const terminal = RUN_TERMINAL.has(to)
3080
- const recovery = to === "INTERRUPTED" ? (opts?.recoveryStatus ?? "NONE") : "NONE"
3081
- try {
3082
- db.prepare(
3083
- "UPDATE runs SET status = ?, ended_at = ?, recovery_status = ? WHERE run_id = ?",
3084
- ).run(to, terminal ? now : null, recovery, runId)
3085
- } catch (e) {
3086
- if (isRunningUniquenessViolation(e)) throw new RunRunningExistsError(row.session_id)
3087
- throw e
3088
- }
3089
- return rowToRun({
3090
- ...row,
3091
- status: to,
3092
- ended_at: terminal ? now : row.ended_at,
3093
- recovery_status: recovery,
3094
- })
3095
- })()
3096
- } finally {
3097
- db.close()
3098
- }
3099
- }
3100
-
3101
- function isRunningUniquenessViolation(e: unknown): boolean {
3102
- const msg = String((e as Error)?.message ?? e)
3103
- return msg.includes("UNIQUE constraint failed") && msg.includes("runs")
3104
- }
3105
-
3106
- export function completeRun(
3107
- runId: string,
3108
- cwd?: string,
3109
- opts?: { expectedEpoch?: number },
3110
- ): RunRow {
3111
- return transitionRun(runId, "COMPLETED", cwd, opts)
3112
- }
3113
-
3114
- export function failRun(runId: string, cwd?: string, opts?: { expectedEpoch?: number }): RunRow {
3115
- return transitionRun(runId, "FAILED", cwd, opts)
3116
- }
3117
-
3118
- export function interruptRun(
3119
- runId: string,
3120
- cwd?: string,
3121
- opts?: { expectedEpoch?: number; recoveryStatus?: string },
3122
- ): RunRow {
3123
- return transitionRun(runId, "INTERRUPTED", cwd, opts)
3124
- }
3125
-
3126
- // Kursor eksplisit: monoton (CAS pada nilai terbaca — tanpa lost-update),
3127
- // dalam-head, milik-run ini (NULL warisan boleh; run lain ditolak).
3128
- // Versi in-txn dipakai appendHistoryEvent supaya event+kursor satu commit.
3129
- function advanceRunCursorInTxn(
3130
- db: Database,
3131
- runId: string,
3132
- seq: number,
3133
- expectSessionId: string | undefined,
3134
- opts?: { expectedEventId?: string },
3135
- ): RunRow {
3136
- const row = db
3137
- .prepare(`SELECT ${RUN_COLUMNS} FROM runs WHERE run_id = ?`)
3138
- .get(runId) as RunRow | null
3139
- if (!row) throw new Error(`run not found: ${runId}`)
3140
- if (expectSessionId !== undefined && row.session_id !== expectSessionId)
3141
- throw new Error(`run ${runId} does not belong to session ${expectSessionId}`)
3142
- if (RUN_TERMINAL.has(row.status))
3143
- throw new RunStatusError(runId, row.status, `${row.status}+cursor`)
3144
- if (!Number.isInteger(seq) || seq < 0)
3145
- throw new RunCursorError("RUN_CURSOR_BEYOND_HEAD", runId, `invalid seq ${seq}`)
3146
- const target = db
3147
- .prepare(
3148
- "SELECT seq, run_id, event_id FROM messages WHERE session_id = ? AND thread_id = ? AND seq = ?",
3149
- )
3150
- .get(row.session_id, row.thread_id, seq) as {
3151
- seq: number
3152
- run_id: string | null
3153
- event_id: string | null
3154
- } | null
3155
- if (!target)
3156
- throw new RunCursorError("RUN_CURSOR_BEYOND_HEAD", runId, `no durable event at seq ${seq}`)
3157
- if (target.run_id !== null && target.run_id !== runId) {
3158
- throw new RunCursorError(
3159
- "RUN_CURSOR_FOREIGN",
3160
- runId,
3161
- `seq ${seq} belongs to run ${target.run_id}`,
3162
- )
3163
- }
3164
- if (opts?.expectedEventId !== undefined && target.event_id !== opts.expectedEventId) {
3165
- throw new RunCursorError("RUN_CURSOR_FOREIGN", runId, `seq ${seq} event mismatch`)
3166
- }
3167
- if (seq < row.last_persisted_seq) {
3168
- throw new RunCursorError(
3169
- "RUN_CURSOR_BACKWARD",
3170
- runId,
3171
- `${row.last_persisted_seq} → ${seq} refused (no rewind in P2.6)`,
3172
- )
3173
- }
3174
- if (seq === row.last_persisted_seq) return rowToRun(row)
3175
- const upd = db
3176
- .prepare("UPDATE runs SET last_persisted_seq = ? WHERE run_id = ? AND last_persisted_seq = ?")
3177
- .run(seq, runId, row.last_persisted_seq)
3178
- if (upd.changes === 0) {
3179
- const cur = db.prepare("SELECT last_persisted_seq FROM runs WHERE run_id = ?").get(runId) as {
3180
- last_persisted_seq: number
3181
- }
3182
- throw new RunCursorError(
3183
- "RUN_CURSOR_BACKWARD",
3184
- runId,
3185
- `concurrent advance observed (now ${cur.last_persisted_seq})`,
3186
- )
3187
- }
3188
- return rowToRun({ ...row, last_persisted_seq: seq })
3189
- }
3190
-
3191
- export function advanceRunCursor(
3192
- runId: string,
3193
- seq: number,
3194
- cwd?: string,
3195
- opts?: { expectedEpoch?: number; expectedEventId?: string },
3196
- ): RunRow {
3197
- const db = open(cwd)
3198
- try {
3199
- return db.transaction(() => {
3200
- if (opts?.expectedEpoch !== undefined) {
3201
- const owner = db.prepare("SELECT session_id FROM runs WHERE run_id = ?").get(runId) as {
3202
- session_id: string
3203
- } | null
3204
- if (!owner) throw new Error(`run not found: ${runId}`)
3205
- assertWriterEpochInTxn(db, owner.session_id, opts.expectedEpoch)
3206
- }
3207
- return advanceRunCursorInTxn(db, runId, seq, undefined, opts)
3208
- })()
3209
- } finally {
3210
- db.close()
3211
- }
3212
- }
3213
-
3214
- // Metadata pending_tool_ids (dorman P2.6): round-trip tervalidasi, fenced.
3215
- // BUKAN bukti eksekusi — tak ada semantik tool di sini.
3216
- export function setRunPendingTools(
3217
- runId: string,
3218
- pendingToolIds: unknown,
3219
- cwd?: string,
3220
- opts?: { expectedEpoch?: number },
3221
- ): RunRow {
3222
- const db = open(cwd)
3223
- try {
3224
- return db.transaction(() => {
3225
- const row = db
3226
- .prepare(`SELECT ${RUN_COLUMNS} FROM runs WHERE run_id = ?`)
3227
- .get(runId) as RunRow | null
3228
- if (!row) throw new Error(`run not found: ${runId}`)
3229
- if (opts?.expectedEpoch !== undefined)
3230
- assertWriterEpochInTxn(db, row.session_id, opts.expectedEpoch)
3231
- const pending = validatePendingToolIds(pendingToolIds)
3232
- db.prepare("UPDATE runs SET pending_tool_ids = ? WHERE run_id = ?").run(pending, runId)
3233
- return rowToRun({ ...row, pending_tool_ids: pending })
3234
- })()
3235
- } finally {
3236
- db.close()
3237
- }
3238
- }
3239
-
3240
- // Tombstone crash-residue: SEMUA RUNNING sesi ini (tanpa holder hidup —
3241
- // admission membuktikannya) menjadi INTERRUPTED + recovery UNKNOWN dengan
3242
- // ended_at NULL (kematian tak terobservasi). Satu statement (atomik, tanpa
3243
- // TOCTOU). BUKAN auto-continue/replay: resolusi milik fase mendatang.
3244
- // Fenced; idempoten (pemanggilan kedua nihil).
3245
- export function tombstoneDeadRuns(
3246
- sessionId: string,
3247
- cwd?: string,
3248
- opts?: { expectedEpoch?: number },
3249
- ): number {
3250
- const db = open(cwd)
3251
- try {
3252
- return db.transaction(() => {
3253
- if (opts?.expectedEpoch !== undefined)
3254
- assertWriterEpochInTxn(db, sessionId, opts.expectedEpoch)
3255
- const res = db
3256
- .prepare(
3257
- "UPDATE runs SET status = 'INTERRUPTED', recovery_status = 'UNKNOWN' WHERE session_id = ? AND status = 'RUNNING'",
3258
- )
3259
- .run(sessionId)
3260
- return res.changes
3261
- })()
3262
- } finally {
3263
- db.close()
3264
- }
3265
- }
3266
-
3267
2376
  // ── P2.7 — Projection foundation ────────────────────────────────────────────
3268
2377
  // Proyeksi = representasi TURUNAN dari messages (read-only build, rebuildable,
3269
2378
  // tak pernah otoritatif). Satu-satunya jenis P2.7: "summary" (ringkasan prefix).