hub (unreleased): a deleted box or household leaves no rows in the tables that had no delete; the delete journal stays (R-1376, D73)
gates / gates (push) Successful in 2m4s

Claude-Session: https://claude.ai/code/session_0159rPz1ZhFKsS53msqPYxtS
This commit is contained in:
admin committed 2026-11-14 18:32:34 +01:00
1 parent 0ce752a370
commit 73d99d06c5
12 files changed
+440 -5

No files matched your search

+6
View File
@@ -3,6 +3,12 @@
- `bundlefiles`: the line „bundle X holds the same files as the vouched Y” is logged once per pair (INFO), not at
every view of the System page (it was 6 DEBUG lines per view, seen at the 0.181.0 deploy). No behaviour change.
- **Release 3 („the hub tells you”), built 2026-11-14 night, NOT deployed. Every new alarm is operator-only.**
- **A deleted box or household leaves no rows in the tables that had no delete (R-1376 part 1, D73, `09` §3 decision
293; `05` §14.2).** `DeleteHost` also removes the box's `os_host_settings`, `os_reports`, `os_kernel_notices` and the
hub's alarm marks that name it; `PurgeCustomerResidue` also removes the household's `offsite_keys`,
`offsite_windows`, `offsite_abandon_requests` (and the delete dialog counts them); `operator_actions` goes with the
audit rows one year after the deletion. **The delete journal stays** (`host_deletions`, `customer_resets`).
`PurgeOrphanRows` in the daily prune removes what earlier deletes left. Tests `TestD73_*`; 16 mutations seen red.
- **Two end dates warn 14 days before (R-1379, D77, `09` §3 decision 298; `08` §12).** `monitor.EndDateChecker`, hourly
on the sweep: `operator_token_ends_soon` for an operator access token that is not revoked, and `web_cert_ends_soon`
for a web certificate a box reports in `web_certs` (controllers after 0.352.1). Told once at 14 days and once more,
+7
View File
@@ -1214,6 +1214,13 @@ func pruneAll(s *store.Store, maxDays int, logger *log.Logger) {
} else if n > 0 {
logger.Printf("[INFO] Pruned %d stale app issues", n)
}
// D73 (`09` §3 decision 293, R-1376): the rows a box or household deleted BEFORE this release left in the six
// tables that had no delete. A delete now leaves none, so this finds something only once.
if orphans, err := s.PurgeOrphanRows(); err != nil {
logger.Printf("[ERROR] Purge rows of deleted boxes and households: %v", err)
} else if orphans.Total() > 0 {
logger.Printf("[INFO] Purged %d row(s) of boxes and households that no longer exist: %v", orphans.Total(), map[string]int64(orphans))
}
// R-901 (`09` §3 decision 181): a deleted customer's audit rows go 1 year after the deletion.
if ev, nl, err := s.PruneDeletedCustomerAudit(time.Now().UTC(), store.DeletedCustomerAuditKeep); err != nil {
logger.Printf("[ERROR] Prune deleted customers' audit rows: %v", err)
+3 -1
View File
@@ -60,6 +60,8 @@ func TestR1383_MainWiresTheSilentFailureChecks(t *testing.T) {
seen["lost-mail scan"]++
case recv == "signedJobWaitChecker" && name == "Check":
seen["signed-job sweep"]++
case name == "PurgeOrphanRows" && fn.Name.Name == "pruneAll":
seen["orphan sweep in the daily prune"]++ // D73, R-1376
case recv == "endDateChecker" && name == "Check":
seen["end-date sweep"]++ // R-1379
}
@@ -67,7 +69,7 @@ func TestR1383_MainWiresTheSilentFailureChecks(t *testing.T) {
return true
})
}
for _, k := range []string{"ledger built", `watched "deadline-check"`, `watched "offsite-key-audit"`, "lost-mail scan", "signed-job sweep", "end-date sweep"} {
for _, k := range []string{"ledger built", `watched "deadline-check"`, `watched "offsite-key-audit"`, "lost-mail scan", "signed-job sweep", "end-date sweep", "orphan sweep in the daily prune"} {
if seen[k] != 1 {
t.Errorf("main.go: %s — found %d time(s), want 1", k, seen[k])
}
+17 -1
View File
@@ -24,6 +24,13 @@ import "fmt"
// What deliberately SURVIVES (unchanged from every other tier): `events` (the audit stream),
// `notification_log` (the send-attempt audit), `host_deletions` and `customer_resets` (F-14
// provenance). The audit trail outlives every lifecycle tier — that rule is not relaxed here.
//
// D73 (`09` §3 decision 293, R-1376): „deleting a household or a box deletes its rows in the tables that have no
// delete today” — with ONE exception, the delete journal (`host_deletions`, `customer_resets`), which stays for ever
// and which the privacy text must name. So: the three off-site tables go with this purge; the box's three update
// tables go with DeleteHost; and `operator_actions` — the operator's own action log, an audit record like `events`
// — goes with the audit rows, one year after the deletion (PruneDeletedCustomerAudit; decided by CC unattended,
// the operator may reverse). Rows left by households and boxes deleted BEFORE this: PurgeOrphanRows, daily.
// CustomerResidue counts what a customer has left behind OUTSIDE the config row: the report-derived
// state that keeps a deleted customer visible and alerting, plus the credential-bearing bindings.
@@ -39,6 +46,11 @@ type CustomerResidue struct {
// AppLogIssueRefs (R-244, v0.147.0): shared app_log_issues rows naming the customer. De-referenced
// (never blindly deleted) by the purge — see app_log_residue.go.
AppLogIssueRefs int
// D73 (`09` §3 decision 293, R-1376): the three household-keyed tables that had no delete statement anywhere —
// the off-site key record, the off-site clean-up windows and the abandon requests. They outlived the household.
OffsiteKeys int
OffsiteWindows int
OffsiteAbandonRequests int
}
// Total is the single number the "is there anything left at all?" decision hangs on.
@@ -47,7 +59,8 @@ func (r *CustomerResidue) Total() int {
return 0
}
return r.Reports + r.AppTelemetry + r.AppLogTails + r.LogTailRequests +
r.NotificationPrefs + r.SelfBindTokens + r.ApplianceRegistrations + r.AppLogIssueRefs
r.NotificationPrefs + r.SelfBindTokens + r.ApplianceRegistrations + r.AppLogIssueRefs +
r.OffsiteKeys + r.OffsiteWindows + r.OffsiteAbandonRequests
}
// residueQueries is the ONE list both the counter and the purge walk, so a table can never be
@@ -63,6 +76,9 @@ var residueQueries = []struct {
{"customer_notifications", func(r *CustomerResidue) *int { return &r.NotificationPrefs }},
{"selfbind_tokens", func(r *CustomerResidue) *int { return &r.SelfBindTokens }},
{"appliance_registrations", func(r *CustomerResidue) *int { return &r.ApplianceRegistrations }},
{"offsite_keys", func(r *CustomerResidue) *int { return &r.OffsiteKeys }},
{"offsite_windows", func(r *CustomerResidue) *int { return &r.OffsiteWindows }},
{"offsite_abandon_requests", func(r *CustomerResidue) *int { return &r.OffsiteAbandonRequests }},
}
// CustomerResidue counts the customer's report-derived + binding residue. Read-only.
+225
View File
@@ -0,0 +1,225 @@
package store
import (
"testing"
"time"
)
// d73Seed gives a box rows in the three box-keyed tables that had no delete, and its household rows in the three
// household-keyed ones — plus the hub's own alarm marks that name the box.
func d73Seed(t *testing.T, s *Store, hostID, customerID string) {
t.Helper()
exec := func(q string, a ...any) {
t.Helper()
if _, err := s.db.Exec(q, a...); err != nil {
t.Fatalf("seed %q: %v", q, err)
}
}
exec(`INSERT INTO os_host_settings (host_id, ring, enabled) VALUES (?, 0, 1)`, hostID)
exec(`INSERT INTO os_reports (host_id, layer, outcome, report_json) VALUES (?, 'host', 'nothing', '{}')`, hostID)
exec(`INSERT INTO os_reports (host_id, layer, outcome, report_json) VALUES (?, 'kernel', 'applied', '{}')`, hostID)
exec(`INSERT INTO os_kernel_notices (host_id, kver, sent_at) VALUES (?, '7.0.14-22-pve', datetime('now'))`, hostID)
exec(`INSERT INTO offsite_keys (customer_id, fingerprint) VALUES (?, 'SHA256:x')`, customerID)
exec(`INSERT INTO offsite_windows (customer_id, closes_by) VALUES (?, datetime('now'))`, customerID)
exec(`INSERT INTO offsite_abandon_requests (customer_id, path, due_at) VALUES (?, '.orphaned-1', datetime('now'))`, customerID)
exec(`INSERT INTO operator_actions (customer_id, host_id, action, requested_at) VALUES (?, ?, 'rerun_backup', datetime('now'))`, customerID, hostID)
for _, k := range []string{"box_clock:" + hostID + ":ahead", "pve_trust:" + hostID + ":ca_copy_does_not_verify",
"guest_power:" + hostID + ":9201", "signed_job_wait:" + hostID + ":job1", "wg_stale:" + hostID} {
if err := s.SetOSAlarmRaised(k, time.Now()); err != nil {
t.Fatal(err)
}
}
}
func d73Count(t *testing.T, s *Store, q string, args ...any) int {
t.Helper()
var n int
if err := s.db.QueryRow(q, args...).Scan(&n); err != nil {
t.Fatalf("count %q: %v", q, err)
}
return n
}
func d73Counts(t *testing.T, s *Store, hostID, customerID string) map[string]int {
t.Helper()
return map[string]int{
"os_host_settings": d73Count(t, s, `SELECT COUNT(*) FROM os_host_settings WHERE host_id = ?`, hostID),
"os_reports": d73Count(t, s, `SELECT COUNT(*) FROM os_reports WHERE host_id = ?`, hostID),
"os_kernel_notices": d73Count(t, s, `SELECT COUNT(*) FROM os_kernel_notices WHERE host_id = ?`, hostID),
"alarm marks": d73Count(t, s, `SELECT COUNT(*) FROM hub_settings WHERE key LIKE 'os_alarm:%' AND instr(key, ?) > 0`, hostID),
"offsite_keys": d73Count(t, s, `SELECT COUNT(*) FROM offsite_keys WHERE customer_id = ?`, customerID),
"offsite_windows": d73Count(t, s, `SELECT COUNT(*) FROM offsite_windows WHERE customer_id = ?`, customerID),
"offsite_abandon_requests": d73Count(t, s, `SELECT COUNT(*) FROM offsite_abandon_requests WHERE customer_id = ?`, customerID),
"operator_actions": d73Count(t, s, `SELECT COUNT(*) FROM operator_actions WHERE customer_id = ?`, customerID),
}
}
var d73BoxTables = []string{"os_host_settings", "os_reports", "os_kernel_notices", "alarm marks"}
var d73HouseholdTables = []string{"offsite_keys", "offsite_windows", "offsite_abandon_requests"}
// D73 (`09` §3 decision 293, R-1376): deleting a BOX deletes its rows in the three box-keyed tables that had no
// delete statement, and the hub's alarm marks that name it. The household's rows stay (the household is still
// there), the other box is untouched — also one whose id only STARTS with this box's id — and the delete journal has
// its row. COMPANION RED-PROOFS (observed, audits/night-build-2026-11-14/B/redproof-hub-d73.txt).
func TestD73_DeleteHostRemovesTheBoxesRows(t *testing.T) {
s := newTestStore(t)
for _, h := range []struct{ host, cust string }{{"box-a1", "cust-a"}, {"box-a1b", "cust-b"}, {"x-box-a1", "cust-c"}} {
if err := s.UpsertHost(&Host{HostID: h.host, CustomerID: h.cust, APIKey: "k-" + h.host}); err != nil {
t.Fatal(err)
}
d73Seed(t, s, h.host, h.cust)
}
before := d73Counts(t, s, "box-a1", "cust-a")
for table, n := range before {
if n == 0 {
t.Fatalf("fixture gap: %s has no row", table)
}
}
otherB, otherC := d73Counts(t, s, "box-a1b", "cust-b"), d73Counts(t, s, "x-box-a1", "cust-c")
if err := s.DeleteHost("box-a1", true); err != nil {
t.Fatal(err)
}
after := d73Counts(t, s, "box-a1", "cust-a")
// "alarm marks" counts by a substring, so the two look-alike boxes' marks (box-a1b, x-box-a1) are in it: those
// must be all that is left.
lookAlikes := 2 * 5
for _, table := range d73BoxTables {
want := 0
if table == "alarm marks" {
want = lookAlikes
}
if after[table] != want {
t.Errorf("%s: %d row(s) left for the deleted box (want %d)", table, after[table], want)
}
}
for _, table := range append(d73HouseholdTables, "operator_actions") {
if after[table] != before[table] {
t.Errorf("%s: %d → %d — a box delete must leave the HOUSEHOLD's rows (the household still exists)", table, before[table], after[table])
}
}
for name, pair := range map[string][2]map[string]int{"box-a1b": {otherB, d73Counts(t, s, "box-a1b", "cust-b")}, "x-box-a1": {otherC, d73Counts(t, s, "x-box-a1", "cust-c")}} {
for _, table := range []string{"os_host_settings", "os_reports", "os_kernel_notices", "offsite_keys", "operator_actions"} {
if pair[0][table] != pair[1][table] {
t.Errorf("another box (%s) lost rows in %s: %d → %d", name, table, pair[0][table], pair[1][table])
}
}
if n := d73Count(t, s, `SELECT COUNT(*) FROM hub_settings WHERE key LIKE 'os_alarm:%' AND (instr(key, ':'||?||':') > 0 OR key LIKE '%:'||?)`, name, name); n != 5 {
t.Errorf("another box (%s) has %d alarm mark(s) left, want its 5", name, n)
}
}
if n := d73Count(t, s, `SELECT COUNT(*) FROM host_deletions WHERE host_id = 'box-a1'`); n != 1 {
t.Errorf("the delete journal has %d row(s) for the box, want 1 — the journal STAYS", n)
}
}
// Deleting a HOUSEHOLD (the purge leg) deletes its rows in the three household-keyed tables, counts them in the
// preview's residue, and leaves the two journals alone. The operator's action log is an audit record: it stays at the
// purge and goes with the audit rows one year after the deletion.
func TestD73_PurgeRemovesTheHouseholdsRows_JournalStays(t *testing.T) {
s := newTestStore(t)
for _, c := range []string{"cust-a", "cust-b"} {
if err := s.SaveCustomerConfig(&CustomerConfig{CustomerID: c, APIKey: "k-" + c, RetrievalPassword: "p"}); err != nil {
t.Fatal(err)
}
d73Seed(t, s, "box-"+c, c)
}
id, err := s.StartCustomerReset("cust-a", false)
if err != nil {
t.Fatal(err)
}
_ = s.UpdateResetLeg(id, "customer_delete", "ok")
_ = s.FinishCustomerReset(id)
if _, err := s.db.Exec(`INSERT INTO host_deletions (host_id, customer_id, escrow_acked) VALUES ('box-cust-a', 'cust-a', 0)`); err != nil {
t.Fatal(err)
}
res, err := s.CustomerResidue("cust-a")
if err != nil || res.OffsiteKeys != 1 || res.OffsiteWindows != 1 || res.OffsiteAbandonRequests != 1 || res.Total() < 3 {
t.Fatalf("the preview's residue does not count the three tables: %+v (%v)", res, err)
}
if err := s.PurgeCustomerResidue("cust-a"); err != nil {
t.Fatal(err)
}
after, other := d73Counts(t, s, "box-cust-a", "cust-a"), d73Counts(t, s, "box-cust-b", "cust-b")
for _, table := range d73HouseholdTables {
if after[table] != 0 {
t.Errorf("%s: %d row(s) outlived the household", table, after[table])
}
if other[table] != 1 {
t.Errorf("%s: the OTHER household has %d row(s), want 1", table, other[table])
}
}
if after["operator_actions"] != 1 {
t.Errorf("operator_actions: %d — the action log is an audit record and stays at the purge", after["operator_actions"])
}
for _, j := range []string{"customer_resets", "host_deletions"} {
if n := d73Count(t, s, `SELECT COUNT(*) FROM `+j+` WHERE customer_id = 'cust-a'`); n != 1 {
t.Errorf("journal %s: %d row(s), want 1 — the delete journal stays (the ruling's one exception)", j, n)
}
}
// the action log goes with the audit rows: not at 100 days, gone after a year
now := time.Now().UTC()
if _, _, err := s.PruneDeletedCustomerAudit(now.Add(100*24*time.Hour), DeletedCustomerAuditKeep); err != nil {
t.Fatal(err)
}
if n := d73Counts(t, s, "box-cust-a", "cust-a")["operator_actions"]; n != 1 {
t.Errorf("operator_actions after 100 days: %d, want 1", n)
}
if _, _, err := s.PruneDeletedCustomerAudit(now.Add(400*24*time.Hour), DeletedCustomerAuditKeep); err != nil {
t.Fatal(err)
}
if n := d73Counts(t, s, "box-cust-a", "cust-a")["operator_actions"]; n != 0 {
t.Errorf("operator_actions a year after the deletion: %d, want 0", n)
}
if n := d73Counts(t, s, "box-cust-b", "cust-b")["operator_actions"]; n != 1 {
t.Errorf("the OTHER household's action log: %d, want 1", n)
}
for _, j := range []string{"customer_resets", "host_deletions"} {
if n := d73Count(t, s, `SELECT COUNT(*) FROM `+j+` WHERE customer_id = 'cust-a'`); n != 1 {
t.Errorf("journal %s after the one-year prune: %d row(s), want 1", j, n)
}
}
}
// The daily sweep is for what was left BEFORE: rows of a box or household that no longer exists. A live box, a live
// household, and a household in the middle of its delete (its boxes are gone, its config is still there) lose nothing.
func TestD73_PurgeOrphanRows_OnlyTheGone(t *testing.T) {
s := newTestStore(t)
// live: a household with a box
_ = s.SaveCustomerConfig(&CustomerConfig{CustomerID: "live", APIKey: "k1", RetrievalPassword: "p"})
_ = s.UpsertHost(&Host{HostID: "live-box", CustomerID: "live", APIKey: "hk1"})
d73Seed(t, s, "live-box", "live")
// mid-delete: the config is there, the box is already gone (so its box rows ARE orphans, its household rows are not)
_ = s.SaveCustomerConfig(&CustomerConfig{CustomerID: "mid", APIKey: "k2", RetrievalPassword: "p"})
d73Seed(t, s, "mid-box", "mid")
// a ghost with a box: the config row is gone, a box row is left → the household still „exists”
_ = s.UpsertHost(&Host{HostID: "ghost-box", CustomerID: "ghost", APIKey: "hk3"})
d73Seed(t, s, "ghost-box", "ghost")
// gone: neither config nor box (Peti's box, the test boxes of 2026-11)
d73Seed(t, s, "gone-box", "gone")
got, err := s.PurgeOrphanRows()
if err != nil {
t.Fatal(err)
}
want := map[string]map[string]int{
"live": {"os_host_settings": 1, "os_reports": 2, "os_kernel_notices": 1, "offsite_keys": 1, "offsite_windows": 1, "offsite_abandon_requests": 1, "operator_actions": 1},
"mid": {"os_host_settings": 0, "os_reports": 0, "os_kernel_notices": 0, "offsite_keys": 1, "offsite_windows": 1, "offsite_abandon_requests": 1, "operator_actions": 1},
"ghost": {"os_host_settings": 1, "os_reports": 2, "os_kernel_notices": 1, "offsite_keys": 1, "offsite_windows": 1, "offsite_abandon_requests": 1, "operator_actions": 1},
"gone": {"os_host_settings": 0, "os_reports": 0, "os_kernel_notices": 0, "offsite_keys": 0, "offsite_windows": 0, "offsite_abandon_requests": 0, "operator_actions": 1},
}
for cust, tables := range want {
c := d73Counts(t, s, cust+"-box", cust)
for table, n := range tables {
if c[table] != n {
t.Errorf("%s / %s: %d row(s), want %d", cust, table, c[table], n)
}
}
}
if got.Total() != 11 || got["os_reports"] != 4 || got["offsite_keys"] != 1 {
t.Errorf("the sweep reported %v (total %d), want 11 rows: 8 box rows of mid and gone, 3 household rows of gone", got, got.Total())
}
again, _ := s.PurgeOrphanRows()
if again.Total() != 0 {
t.Errorf("a second sweep removed %v — it must find nothing", again)
}
}
@@ -65,6 +65,11 @@ func (s *Store) PruneDeletedCustomerAudit(now time.Time, keep time.Duration) (ev
}
n, _ = r.RowsAffected()
notifications += n
// D73 (R-1376): the operator's action log of the deleted household is an audit record of the same kind — it had
// no delete at all; it goes with the other two.
if _, err = s.db.Exec(`DELETE FROM operator_actions WHERE customer_id = ? AND requested_at <= ?`, d.id, cutoff); err != nil {
return events, notifications, fmt.Errorf("PruneDeletedCustomerAudit %s: operator_actions: %w", d.id, err)
}
}
return events, notifications, nil
}
+55
View File
@@ -0,0 +1,55 @@
package store
import "fmt"
// OrphanRows counts what PurgeOrphanRows removed, per table.
type OrphanRows map[string]int64
// Total is the sum.
func (o OrphanRows) Total() int64 {
var n int64
for _, v := range o {
n += v
}
return n
}
// orphanTables are the tables D73 names (`09` §3 decision 293, R-1376) — the ones that had no delete statement — each
// with the column that names its owner and the query that says „the owner still exists”.
//
// A BOX exists while it has a `hosts` row. A HOUSEHOLD exists while it has a config row OR a box: a „ghost” (the
// config row gone, residue left) is exactly what this sweep is for, but a household in the middle of its delete
// cascade (boxes gone, config still there) is not an orphan.
var orphanTables = []struct{ table, where string }{
{"os_host_settings", `host_id NOT IN (SELECT host_id FROM hosts)`},
{"os_reports", `host_id NOT IN (SELECT host_id FROM hosts)`},
{"os_kernel_notices", `host_id NOT IN (SELECT host_id FROM hosts)`},
{"offsite_keys", `customer_id NOT IN (SELECT customer_id FROM customer_configs) AND customer_id NOT IN (SELECT customer_id FROM hosts)`},
{"offsite_windows", `customer_id NOT IN (SELECT customer_id FROM customer_configs) AND customer_id NOT IN (SELECT customer_id FROM hosts)`},
{"offsite_abandon_requests", `customer_id NOT IN (SELECT customer_id FROM customer_configs) AND customer_id NOT IN (SELECT customer_id FROM hosts)`},
}
// PurgeOrphanRows removes, in ONE transaction, the rows of boxes and households that no longer exist from the six
// tables that had no delete statement (D73). It is the daily clean-up for what was left BEFORE DeleteHost and
// PurgeCustomerResidue learned those tables (Peti's box, the test boxes of 2026-11): from now on a delete leaves
// nothing for it. It never touches the delete journal (`host_deletions`, `customer_resets`), `events`,
// `notification_log` or `operator_actions` (those go by the one-year rule). Idempotent.
// Pinned by TestD73_PurgeOrphanRows_OnlyTheGone.
func (s *Store) PurgeOrphanRows() (OrphanRows, error) {
tx, err := s.db.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
out := OrphanRows{}
for _, t := range orphanTables {
res, err := tx.Exec(`DELETE FROM ` + t.table + ` WHERE ` + t.where)
if err != nil {
return nil, fmt.Errorf("PurgeOrphanRows %s: %w", t.table, err)
}
if n, _ := res.RowsAffected(); n > 0 {
out[t.table] = n
}
}
return out, tx.Commit()
}
+11
View File
@@ -3322,6 +3322,11 @@ func (s *Store) DeleteHost(hostID string, deleteEscrow bool) error {
`DELETE FROM log_bundle_requests WHERE scope_id = ?`,
`DELETE FROM log_bundles WHERE scope_id = ?`,
`DELETE FROM wg_peers WHERE host_id = ?`,
// D73 (`09` §3 decision 293, R-1376): the three box-keyed tables that had no delete at all. A deleted box
// kept its update settings, every update report it ever sent, and its kernel notices — for ever.
`DELETE FROM os_host_settings WHERE host_id = ?`,
`DELETE FROM os_reports WHERE host_id = ?`,
`DELETE FROM os_kernel_notices WHERE host_id = ?`,
`DELETE FROM hosts WHERE host_id = ?`,
}
for _, q := range stmts {
@@ -3329,6 +3334,12 @@ func (s *Store) DeleteHost(hostID string, deleteEscrow bool) error {
return fmt.Errorf("DeleteHost %s: %q: %w", hostID, q, err)
}
}
// D73: the hub's own small alarm marks that NAME the box (`os_alarm:<kind>:<host>[:…]` — a clock alarm, a trust
// cause, a guest the watchdog gave up on, a signed job). instr, not LIKE: a host id may hold `_` or `%`.
if _, err := tx.Exec(`DELETE FROM hub_settings WHERE key LIKE 'os_alarm:%' AND
(instr(key, ':' || ?1 || ':') > 0 OR substr(key, -(length(?1) + 1)) = ':' || ?1)`, hostID); err != nil {
return fmt.Errorf("DeleteHost %s: alarm marks: %w", hostID, err)
}
return tx.Commit()
}