fix(modules): three defects a real install exposed (phase 4, slice 1)

Standing the slice-2 screen up against a live server and installing the
published module-uo v0.3.0 through it found three things, none of which any
unit test in this repo could have caught. Two of them are older than this
phase.

1. The boot refresh nulled every install's provenance
--------------------------------------------------------
`installed_modules.source` and `.sha256` exist so the admin panel can say
where a module came from. They never survived a restart.

`lifecycle.boot()` re-records every scanned module with no source and no
sha256 -- correctly, because a scan finds a directory and never where it came
from -- and `upsert` assigned both columns unconditionally. So an install's
provenance lasted exactly until the restart that install asked for, and the
screen then described a module installed from a URL as "placed on the volume
by hand". Verified live: install, restart, provenance gone.

Nothing could have caught it before now. Phase 4 wrote the first non-null
value these columns had ever had, so lifecycle.js's comment asserting that
"recordInstalled leaves what it is not given" described an intention rather
than the statement below it -- and modules.model.test.js's fake reproduced
the defect faithfully, assigning unconditionally just like the SQL.

Fixed with COALESCE(VALUES(col), col): a value overwrites, a NULL leaves what
is there. The fake now matches, and two tests pin both directions -- a boot
refresh must not wipe it, and a re-install from a new URL must still replace
it, or the column would become write-once and an upgrade would for ever show
where the first version came from.

2. The restart killed the server on Windows instead of stopping it
------------------------------------------------------------------
The route called `process.kill(process.pid, 'SIGTERM')` to reach server.js's
graceful-shutdown handler. That works on Linux. **Windows has no POSIX
signals, and Node documents SIGTERM there as unconditional termination of the
target process** -- so on a Windows host the restart killed the server
outright: no module onShutdown, no listener close, no pool close, no log
flush. Observed exactly that: the process was gone and the shutdown handler
had logged nothing at all.

`process.on('SIGTERM', ...)` is an ordinary EventEmitter listener, so
`process.emit('SIGTERM')` reaches the same handler on every platform without
involving the OS. One shutdown path, still; it just gets there by an event.

Deployment is Linux containers and would never have shown this. Development
is not, and neither is the smoke that found it.

The test was worse than useless: it stubbed `process.kill` and asserted it
had been called with SIGTERM, which is precisely the call whose MEANING
differs by platform. It now waits for the SIGTERM EVENT -- what server.js is
actually subscribed to -- so a pass here means the handler would run.

3. `present()` did not publish the running version
--------------------------------------------------
An upgrade writes new files and a new row while the old code stays loaded, so
the row's version is a promise about the next boot rather than a description
of this one. Adds `liveVersion` from the loader beside `liveState`, so the
screen can tell the two apart instead of reporting the new version as running.

723 server tests (+2), manifest and OpenAPI both unchanged.

Co-Authored-By: Claude <noreply@anthropic.com>

server/test/adminModules.test.js

@@ -422,42 +422,55 @@ test('an empty allowlist is storable, and means no installs', async () => {
 
 // ── restart ────────────────────────────────────────────────────────────────
 
-test('restart answers before it signals, and signals its own process', async () => {
-  // It raises SIGTERM rather than calling the shutdown path directly, so that
-  // server.js's handler stays the ONE graceful-shutdown path and this route
-  // cannot drift from it.
-  const originalKill = process.kill
-  const signals = []
-  process.kill = (pid, signal) => { signals.push({ pid, signal }) }
+// These listen for the SIGTERM EVENT rather than stubbing `process.kill`, and
+// that is the whole point of them now.
+//
+// The first version of this route called `process.kill(process.pid, 'SIGTERM')`
+// and the first version of these tests stubbed `process.kill` and asserted it
+// had been called with SIGTERM. Both passed. Both were wrong: Windows has no
+// POSIX signals, and Node documents SIGTERM there as unconditional termination —
+// so on a Windows host the route killed the server outright, with no module
+// `onShutdown`, no pool close and no log flush. A stub of `process.kill` cannot
+// see that, because what it asserts is precisely the call whose MEANING differs
+// by platform.
+//
+// Asserting on the event closes the gap: it is what server.js's handler is
+// actually subscribed to, so a test passing here means the handler would run.
+function onceSigterm() {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      process.removeListener('SIGTERM', handler)
+      reject(new Error('no SIGTERM was emitted within 1s'))
+    }, 1000)
+    function handler() {
+      clearTimeout(timer)
+      process.removeListener('SIGTERM', handler)
+      resolve(true)
+    }
+    process.on('SIGTERM', handler)
+  })
+}
 
-  try {
-    const res = mockRes()
-    ctrl.restart(req(), res)
+test('restart answers first, then triggers the one graceful-shutdown path', async () => {
+  const fired = onceSigterm()
+  const res = mockRes()
 
-    // Answered synchronously: once the signal lands there is no listener left to
-    // flush a response through, so the operator would be told nothing.
-    assert.equal(res.statusCode, 202)
-    assert.equal(res.body.restarting, true)
+  ctrl.restart(req(), res)
 
-    await new Promise((resolve) => setTimeout(resolve, 400))
-    assert.deepEqual(signals, [{ pid: process.pid, signal: 'SIGTERM' }])
-    assert.equal(logged[0].action, 'module.restart')
-  } finally {
-    process.kill = originalKill
-  }
+  // Answered synchronously: once the shutdown starts there is no listener left
+  // to flush a response through, so the operator would be told nothing.
+  assert.equal(res.statusCode, 202)
+  assert.equal(res.body.restarting, true)
+
+  assert.equal(await fired, true)
+  assert.equal(logged[0].action, 'module.restart')
 })
 
 test('a failure to write the audit entry does not cancel the restart', async () => {
-  const originalKill = process.kill
-  const signals = []
-  process.kill = (pid, signal) => { signals.push(signal) }
   activity.log = async () => { throw new Error('database is gone') }
+  const fired = onceSigterm()
 
-  try {
-    ctrl.restart(req(), mockRes())
-    await new Promise((resolve) => setTimeout(resolve, 400))
-    assert.deepEqual(signals, ['SIGTERM'])
-  } finally {
-    process.kill = originalKill
-  }
+  ctrl.restart(req(), mockRes())
+
+  assert.equal(await fired, true)
 })