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.
- package/README.md +1 -1
- package/cli/args.ts +93 -70
- package/cli/bootstrap/presentation-bridge.ts +383 -0
- package/cli/commands/acp.ts +7 -1
- package/cli/commands/doctor.ts +7 -3
- package/cli/commands/exec.ts +6 -16
- package/cli/index.ts +3 -2
- package/cli/setup.ts +13 -380
- package/docs/TERMINAL_CONTRACT.md +5 -5
- package/docs/architecture.md +14 -29
- package/package.json +1 -1
- package/src/app/session.ts +25 -2
- package/src/app/tool-layer.ts +27 -0
- package/src/lib/atomic-write.ts +31 -59
- package/src/policy/jail.ts +6 -8
- package/src/providers/anthropic.ts +16 -5
- package/src/providers/responses.ts +37 -7
- package/src/providers/sse-bounds.ts +6 -4
- package/src/session/db/runs.ts +397 -0
- package/src/session/db/schema.ts +358 -0
- package/src/session/persistence.ts +64 -955
- package/src/task/db/schema.ts +325 -0
- package/src/task/db/types.ts +269 -0
- package/src/task/store.ts +74 -986
- package/src/ui/tui/transcript.ts +4 -0
- package/vendor/minicore/src/providers/openai-compat.ts +7 -0
|
@@ -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 {
|
|
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
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
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).
|