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