rollbridge 0.1.40 → 0.1.42

package/src/process-guardian.js

@@ -259,7 +259,7 @@ async function handleLine(socket, line) {
 async function execute(request, socket) {
   if (shuttingDown) throw new Error("Process guardian is shutting down")
 
-  if (request.command === "capabilities") return {daemonRecovery: 1}
+  if (request.command === "capabilities") return {daemonRecovery: 1, generationReactivation: 1}
 
   if (request.command === "owner-replacement-capabilities") {
     return {commands: ["commit-retired-owner-replacement"], protocol: "owner-replacement", version: 1}
@@ -655,6 +655,9 @@ async function execute(request, socket) {
     await record.process.start(request.reason, request.lifecycleRole)
   } else if (request.command === "activate") {
     await record.process.activateStrict()
+  } else if (request.command === "reactivate" || request.command === "reactivate-with-command") {
+    await record.process.reactivateStrict()
+    record.desired = true
   } else if (request.command === "quiesce") {
     record.desired = false
     await record.process.quiesceStrict()

package/src/release-group.js

@@ -279,6 +279,28 @@ export default class ReleaseGroup extends EventEmitter {
     await instance.process.activateStrict()
   }
 
+  /** Restores the retained generation coordinator to its active role in place. */
+  async reactivateGeneration() {
+    if (this.state !== "draining" && this.state !== "active") throw new Error(`Generation ${this.releaseId} is not retained for reactivation`)
+    const processConfig = this.config.processes.find((candidate) => candidate.lifecycle.activateCommand !== undefined)
+
+    if (!processConfig) throw new Error(`Generation ${this.releaseId} has no activation lifecycle`)
+    const [coordinator] = this.getProcesses(processConfig.id)
+
+    if (!coordinator) throw new Error(`Generation activation process ${processConfig.id} is not retained for release ${this.releaseId}`)
+    const generationIds = new Set([...this.handoffServiceIds, ...this.nonBlockingDrainIds])
+
+    for (const [id, processInstance] of this.processes) {
+      if (generationIds.has(id) && processInstance !== coordinator.process) await processInstance.reactivateStrict()
+    }
+    await coordinator.process.reactivateStrict()
+    this.state = "active"
+    this.activatedAt = new Date().toISOString()
+    this.drainStartedAt = undefined
+    this.retirementError = undefined
+    this.stoppedAt = undefined
+  }
+
   /**
    * Restarts only the exact processes reconstructed for a committed generation.
    * The caller must prove the durable transition identity before using this path.

package/test/completion.test.js

@@ -41,9 +41,10 @@ test("completion bash prints a sourceable script with commands and option flags"
 
   assert.notEqual(code, 1)
   assert.match(output, /complete -F _rollbridge rollbridge/)
-  assert.match(output, /compgen -W "daemon deploy rollback ensure-daemon status stop restart shutdown validate doctor logs events predeploy-cleanup recover completion"/)
+  assert.match(output, /compgen -W "daemon deploy rollback recover-generation-transition ensure-daemon status stop restart shutdown validate doctor logs events predeploy-cleanup recover completion"/)
   // A command's own options are completed after the command.
   assert.match(output, /deploy\)\n\s+opts="[^"]*--release-path[^"]*"/)
+  assert.match(output, /recover-generation-transition\)\n\s+opts="--config --release-path --release-id --revision --previous-release-id"/)
   assert.match(output, /ensure-daemon\)\n\s+opts="[^"]*--daemon-runtime-path[^"]*"/)
   assert.match(output, /restart\)\n\s+opts="[^"]*--policy[^"]*"/)
 })
@@ -53,7 +54,8 @@ test("completion zsh prints a #compdef script with per-command options", async (
 
   assert.match(output, /^#compdef rollbridge/)
   assert.match(output, /compdef _rollbridge rollbridge/)
-  assert.match(output, /commands=\(daemon deploy rollback ensure-daemon status stop restart shutdown validate doctor logs events predeploy-cleanup recover completion\)/)
+  assert.match(output, /commands=\(daemon deploy rollback recover-generation-transition ensure-daemon status stop restart shutdown validate doctor logs events predeploy-cleanup recover completion\)/)
+  assert.match(output, /recover-generation-transition\) compadd -- --config --release-path --release-id --revision --previous-release-id/)
   assert.match(output, /events\) compadd -- [^\n]*--limit/)
 })
 

package/test/config-examples.test.js

@@ -27,6 +27,7 @@ test("TensorBuzz example config loads", async () => {
       ["web", "proxied"]
     ]
   )
+  assert.equal(config.processes[2].lifecycle.reactivateCommand, "appctl jobs-worker-reactivate --pid $ROLLBRIDGE_PID")
   assert.equal(config.processes[3].env.VELOCIOUS_BACKGROUND_JOBS_PORT, "{{ports.background-jobs-main}}")
 })
 

package/test/config-validation.test.js

@@ -180,18 +180,20 @@ test("validateConfig defaults lifecycle, accepts hooks, and rejects bad values",
   })
 
   // Omitted → no commands, zero drain.
-  assert.deepEqual(validateLifecycle(undefined).config.processes[0].lifecycle, {drainTimeoutMs: 0})
+  assert.deepEqual(validateLifecycle(undefined).config.processes[0].lifecycle, {activateTimeoutMs: 30000, drainTimeoutMs: 0})
 
-  const custom = validateLifecycle({drainTimeoutMs: 30000, quietCommand: "kill -TSTP $ROLLBRIDGE_PID", stopCommand: "kill -TERM $ROLLBRIDGE_PID"})
+  const custom = validateLifecycle({activateTimeoutMs: 60000, drainTimeoutMs: 30000, quietCommand: "kill -TSTP $ROLLBRIDGE_PID", stopCommand: "kill -TERM $ROLLBRIDGE_PID"})
 
   assert.deepEqual(custom.issues, [])
   assert.equal(custom.config.processes[0].lifecycle.quietCommand, "kill -TSTP $ROLLBRIDGE_PID")
   assert.equal(custom.config.processes[0].lifecycle.stopCommand, "kill -TERM $ROLLBRIDGE_PID")
+  assert.equal(custom.config.processes[0].lifecycle.activateTimeoutMs, 60000)
   assert.equal(custom.config.processes[0].lifecycle.drainTimeoutMs, 30000)
 
-  const invalid = validateLifecycle({drainTimeoutMs: -1, quietCommand: 5})
+  const invalid = validateLifecycle({activateTimeoutMs: 0, drainTimeoutMs: -1, quietCommand: 5})
   const messages = invalid.issues.map((issue) => issue.message)
 
+  assert.ok(messages.includes("processes[0].lifecycle.activateTimeoutMs must be a positive number"), JSON.stringify(messages))
   assert.ok(messages.includes("processes[0].lifecycle.drainTimeoutMs must be a non-negative number"), JSON.stringify(messages))
   assert.ok(messages.includes("processes[0].lifecycle.quietCommand must be a string"), JSON.stringify(messages))
 
@@ -250,6 +252,24 @@ test("validateConfig accepts one durable handoff activation lifecycle and reject
     {...base.processes[1], id: "jobs-secondary", port: {from: 18200, to: 18299}}
   ]})
   assert.ok(duplicate.issues.some((issue) => /at most one lifecycle\.activateCommand/.test(issue.message)))
+
+  const worker = {
+    command: "run worker",
+    id: "worker",
+    lifecycle: {quietCommand: "worker quiet", reactivateCommand: "worker resume"},
+    nonBlockingDrain: true,
+    policy: "companion"
+  }
+  const pairedWorker = validateConfig({...base, processes: [...base.processes, worker]})
+
+  assert.deepEqual(pairedWorker.issues, [])
+  assert.equal(pairedWorker.config.processes[2].lifecycle.reactivateCommand, "worker resume")
+
+  const unpairedWorker = validateConfig({...base, processes: [...base.processes, {...worker, lifecycle: {quietCommand: "worker quiet"}}]})
+  assert.ok(unpairedWorker.issues.some((issue) => /quietCommand requires lifecycle\.reactivateCommand/.test(issue.message)))
+
+  const unsupportedPlacement = validateConfig({...base, processes: [...base.processes, {...worker, nonBlockingDrain: false}]})
+  assert.ok(unsupportedPlacement.issues.some((issue) => /reactivateCommand.*nonBlockingDrain companion/.test(issue.message)))
 })
 
 test("validateConfig accepts indefinite graceful stop windows", () => {

package/test/guardian-client.test.js

@@ -18,7 +18,7 @@ test("guardian bootstrap capability is absent from process argv", async () => {
   const fixture = await createGuardian()
 
   try {
-    assert.deepEqual(await fixture.client.capabilities(), {daemonRecovery: 1})
+    assert.deepEqual(await fixture.client.capabilities(), {daemonRecovery: 1, generationReactivation: 1})
     const commandLine = await fs.readFile(`/proc/${fixture.client.pid}/cmdline`, "utf8")
     const environment = await fs.readFile(`/proc/${fixture.client.pid}/environ`, "utf8")
     const status = await fs.readFile(`/proc/${fixture.client.pid}/status`, "utf8")
@@ -70,6 +70,87 @@ test("guardian runs a strict activation lifecycle command for the exact register
   }
 })
 
+test("client reactivates a retained process through a guardian without the reactivation command", async () => {
+  const fixture = await createGuardian()
+  const lifecyclePath = path.join(fixture.root, "lifecycle.log")
+  const processInstance = fixture.client.process("compatible-reactivation", {
+    ...definition("compatible-reactivation"),
+    lifecycle: {
+      activateCommand: `printf 'activate\n' >> ${JSON.stringify(lifecyclePath)}`,
+      drainTimeoutMs: 0,
+      quietCommand: `printf 'retire\n' >> ${JSON.stringify(lifecyclePath)}`
+    },
+    shouldRestart: () => true
+  })
+  const request = fixture.client.request.bind(fixture.client)
+
+  fixture.client.request = async command => {
+    if (command.command === "reactivate") throw new Error("Unknown guardian command: reactivate")
+    return await request(command)
+  }
+
+  try {
+    await processInstance.start()
+    await processInstance.activateStrict()
+    const pid = processInstance.status().pid
+
+    await processInstance.quiesceStrict()
+    await processInstance.reactivateStrict()
+
+    assert.equal(processInstance.status().pid, pid)
+    assert.equal(processInstance.status().state, "running")
+    assert.equal(processInstance.status().lifecycleRole, "active")
+    assert.equal(await fs.readFile(lifecyclePath, "utf8"), "activate\nretire\nactivate\n")
+
+    const restarted = once(processInstance, "started")
+
+    assert.ok(pid)
+    process.kill(-pid, "SIGKILL")
+    await restarted
+    assert.notEqual(processInstance.status().pid, pid)
+    assert.equal(processInstance.status().state, "running")
+    assert.equal(processInstance.status().lifecycleRole, "active")
+    assert.equal(await fs.readFile(lifecyclePath, "utf8"), "activate\nretire\nactivate\nactivate\n")
+  } finally {
+    await cleanupGuardian(fixture)
+  }
+})
+
+test("client reverses a worker quiet hook through a pre-reactivation guardian", async () => {
+  const fixture = await createGuardian()
+  const lifecyclePath = path.join(fixture.root, "worker-lifecycle.log")
+  const processInstance = fixture.client.process("compatible-worker-reactivation", {
+    ...definition("compatible-worker-reactivation"),
+    lifecycle: {
+      drainTimeoutMs: 0,
+      quietCommand: `printf 'quiet\n' >> ${JSON.stringify(lifecyclePath)}`,
+      reactivateCommand: `printf 'resume\n' >> ${JSON.stringify(lifecyclePath)}`
+    },
+    shouldRestart: () => true
+  })
+  const request = fixture.client.request.bind(fixture.client)
+
+  fixture.client.request = async command => {
+    if (command.command === "reactivate-with-command") throw new Error("Unknown guardian command: reactivate-with-command")
+    return await request(command)
+  }
+
+  try {
+    await processInstance.start()
+    const pid = processInstance.status().pid
+
+    await processInstance.quiesceStrict()
+    await processInstance.reactivateStrict()
+
+    assert.equal(processInstance.status().pid, pid)
+    assert.equal(processInstance.status().state, "running")
+    assert.equal(processInstance.status().lifecycleRole, "active")
+    assert.equal(await fs.readFile(lifecyclePath, "utf8"), "quiet\nresume\n")
+  } finally {
+    await cleanupGuardian(fixture)
+  }
+})
+
 test("guardian atomically updates process provenance with private owner state", async () => {
   const fixture = await createGuardian()
   const processInstance = fixture.client.process("service", definition("service"))

package/test/managed-process.test.js

@@ -450,14 +450,14 @@ test("activateStrict runs the configured activation command once per call and re
     const pid = managed.pid
 
     assert.ok(pid)
-    managed.lifecycle = {activateCommand: "jobs activate", drainTimeoutMs: 0}
+    managed.lifecycle = {activateCommand: "jobs activate", activateTimeoutMs: 60000, drainTimeoutMs: 0}
     managed.runHook = async (command, timeoutMs, label, hookPid) => {
       commands.push({command, label, pid: hookPid, timeoutMs})
       return undefined
     }
 
     await managed.activateStrict()
-    assert.deepEqual(commands, [{command: "jobs activate", label: "activate command", pid, timeoutMs: 30000}])
+    assert.deepEqual(commands, [{command: "jobs activate", label: "activate command", pid, timeoutMs: 60000}])
 
     managed.runHook = async () => new Error("activation rejected")
     await assert.rejects(() => managed.activateStrict(), /activation rejected/)
@@ -505,6 +505,33 @@ test("activateStrict rejects an activation request when its process is not runni
   assert.equal(hookRan, false)
 })
 
+test("reactivateStrict restores a retained quiesced process only after activation succeeds", async () => {
+  const managed = buildLongLived(() => false)
+  const hooks = /** @type {string[]} */ ([])
+
+  managed.lifecycle = {activateCommand: "jobs activate", drainTimeoutMs: 0, quietCommand: "jobs retire"}
+  managed.runHook = async (_command, _timeoutMs, label) => {
+    hooks.push(label)
+    if (label === "activate command" && hooks.length === 2) return new Error("restoration rejected")
+    return undefined
+  }
+
+  try {
+    await managed.start()
+    await managed.quiesceStrict()
+    await assert.rejects(() => managed.reactivateStrict(), /restoration rejected/)
+    assert.equal(managed.status().state, "quiesced")
+    assert.equal(managed.status().lifecycleRole, "retired")
+
+    await managed.reactivateStrict()
+    assert.equal(managed.status().state, "running")
+    assert.equal(managed.status().lifecycleRole, "active")
+    assert.deepEqual(hooks, ["quiet command", "activate command", "activate command"])
+  } finally {
+    await managed.stop()
+  }
+})
+
 test("quiesce waits for active-role restoration before retiring a restarted process", async () => {
   const managed = buildLongLived(() => false)
   const hooks = /** @type {string[]} */ ([])

package/test/owner-recovery.test.js

@@ -748,7 +748,7 @@ test("guardian recovery becomes ready before replaying a gated generation hook",
   }
 })
 
-test("owner recovery preserves a failed generation transition without firing hooks until exact resume", async () => {
+test("owner recovery preserves a completed activation compensation without replaying hooks", async () => {
   const fixture = await createFixture({activationFailureRelease: "v2"})
   let owner = spawnDaemon(fixture.configPath)
 
@@ -762,7 +762,7 @@ test("owner recovery preserves a failed generation transition without firing hoo
       sendControlCommand({command: {command: "deploy", releaseId: "v2", releasePath: v2Path, revision: "v2"}, path: fixture.socketPath}),
       /activate command exited non-zero/
     )
-    assert.deepEqual(await lifecycleEvents(fixture.lifecycleLogPath), ["activate:v1", "retire:v1"])
+    assert.deepEqual(await lifecycleEvents(fixture.lifecycleLogPath), ["activate:v1", "retire:v1", "retire:v2", "activate:v1"])
 
     owner.kill("SIGKILL")
     await once(owner, "exit")
@@ -771,13 +771,9 @@ test("owner recovery preserves a failed generation transition without firing hoo
 
     const recovered = /** @type {DaemonStatus} */ (await sendControlCommand({command: {command: "status"}, path: fixture.socketPath}))
 
-    assert.equal(recovered.generationTransition?.phase, "activating_candidate")
-    assert.match(String(recovered.generationTransition?.error), /activate command exited non-zero/)
-    assert.deepEqual(await lifecycleEvents(fixture.lifecycleLogPath), ["activate:v1", "retire:v1"], "owner recovery alone must not retry a failed hook")
-
-    await fs.writeFile(fixture.activationGatePath, "allow\n")
-    await sendControlCommand({command: {command: "deploy", releaseId: "v2", releasePath: v2Path, revision: "v2"}, path: fixture.socketPath})
-    assert.deepEqual(await lifecycleEvents(fixture.lifecycleLogPath), ["activate:v1", "retire:v1", "activate:v2"])
+    assert.equal(recovered.activeReleaseId, "v1")
+    assert.equal(recovered.generationTransition, undefined)
+    assert.deepEqual(await lifecycleEvents(fixture.lifecycleLogPath), ["activate:v1", "retire:v1", "retire:v2", "activate:v1"], "owner recovery must not replay completed compensation hooks")
 
     const shutdown = sendControlCommand({command: {command: "shutdown"}, path: fixture.socketPath})
     await Promise.all([v1Path, v2Path].map((releasePath) => fs.writeFile(path.join(releasePath, "worker.fifo"), "drained\n")))
@@ -789,17 +785,14 @@ test("owner recovery preserves a failed generation transition without firing hoo
   }
 })
 
-test("owner recovery replays one journaled ambiguous activation by exact generation identity", async () => {
-  const fixture = await createFixture({activationFailureRelease: "v2"})
+test("owner recovery replays one journaled ambiguous first-generation activation by exact identity", async () => {
+  const fixture = await createFixture({activationFailureRelease: "v1"})
   let owner = spawnDaemon(fixture.configPath)
 
   try {
     await waitForLog(owner, "control socket listening")
     const v1Path = await prepareRelease(fixture.root, "v1")
-    const v2Path = await prepareRelease(fixture.root, "v2")
-
-    await sendControlCommand({command: {command: "deploy", releaseId: "v1", releasePath: v1Path, revision: "v1"}, path: fixture.socketPath})
-    await assert.rejects(sendControlCommand({command: {command: "deploy", releaseId: "v2", releasePath: v2Path, revision: "v2"}, path: fixture.socketPath}))
+    await assert.rejects(sendControlCommand({command: {command: "deploy", releaseId: "v1", releasePath: v1Path, revision: "v1"}, path: fixture.socketPath}))
     owner.kill("SIGKILL")
     await once(owner, "exit")
 
@@ -818,12 +811,12 @@ test("owner recovery replays one journaled ambiguous activation by exact generat
 
     const recovered = /** @type {DaemonStatus} */ (await sendControlCommand({command: {command: "status"}, path: fixture.socketPath}))
 
-    assert.equal(recovered.activeReleaseId, "v2")
+    assert.equal(recovered.activeReleaseId, "v1")
     assert.equal(recovered.generationTransition?.phase, "committed")
-    assert.deepEqual(await lifecycleEvents(fixture.lifecycleLogPath), ["activate:v1", "retire:v1", "activate:v2"])
+    assert.deepEqual(await lifecycleEvents(fixture.lifecycleLogPath), ["activate:v1"])
 
     const shutdown = sendControlCommand({command: {command: "shutdown"}, path: fixture.socketPath})
-    await Promise.all([v1Path, v2Path].map((releasePath) => fs.writeFile(path.join(releasePath, "worker.fifo"), "drained\n")))
+    await fs.writeFile(path.join(v1Path, "worker.fifo"), "drained\n")
     await shutdown
   } finally {
     await killChild(owner)

package/test/owner-replacement.test.js

@@ -1649,7 +1649,7 @@ test("pruned release connection completion closes the incumbent listener session
   assert.equal(daemon.incumbentListenerControl, session)
 })
 
-test("same-authority owner replacement preserves a failed generation transition without retrying its hook", async () => {
+test("same-authority owner replacement preserves completed activation compensation without replaying hooks", async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-owner-replacement-failed-generation-"))
   const oldSocketPath = path.join(root, "old.sock")
   const statePath = path.join(root, "state.json")
@@ -1677,18 +1677,15 @@ test("same-authority owner replacement preserves a failed generation transition
     await waitForLog(owner, "control socket listening")
     await sendControlCommand({command: {command: "deploy", releaseId: "v1", releasePath: v1Path, revision: "v1"}, path: oldSocketPath})
     await assert.rejects(sendControlCommand({command: {command: "deploy", releaseId: "v2", releasePath: v2Path, revision: "v2"}, path: oldSocketPath}), /activate command exited non-zero/)
-    assert.equal(await fs.readFile(lifecycleLogPath, "utf8"), "activate:v1\nretire:v1\n")
+    assert.equal(await fs.readFile(lifecycleLogPath, "utf8"), "activate:v1\nretire:v1\nretire:v2\nactivate:v1\n")
 
     await writeConfig(configPath, failedConfig(oldSocketPath, false))
     candidate = spawn(process.execPath, [binPath, "daemon", "--config", configPath, "--replace-owner"], {stdio: ["ignore", "pipe", "pipe"]})
     await waitForLog(candidate, "owner replacement committed")
     const status = await sendControlCommand({command: {command: "status"}, path: oldSocketPath})
-    const generationTransition = status.generationTransition
-
-    assert.ok(generationTransition && typeof generationTransition === "object" && !Array.isArray(generationTransition))
-    assert.equal(generationTransition.phase, "activating_candidate")
-    assert.match(String(generationTransition.error), /activate command exited non-zero/)
-    assert.equal(await fs.readFile(lifecycleLogPath, "utf8"), "activate:v1\nretire:v1\n", "replacement must preserve, not retry, the failed activation")
+    assert.equal(status.activeReleaseId, "v1")
+    assert.equal(status.generationTransition, undefined)
+    assert.equal(await fs.readFile(lifecycleLogPath, "utf8"), "activate:v1\nretire:v1\nretire:v2\nactivate:v1\n", "replacement must not replay completed compensation hooks")
 
     const shutdown = sendControlCommand({command: {command: "shutdown"}, path: oldSocketPath})
     await Promise.all([v1Path, v2Path].map((releasePath) => fs.writeFile(path.join(releasePath, "worker.fifo"), "drained\n")))
@@ -1700,7 +1697,7 @@ test("same-authority owner replacement preserves a failed generation transition
   }
 })
 
-test("config-changing owner replacement rejects an unresolved generation transition", async () => {
+test("config-changing owner replacement proceeds after activation compensation clears the transition", async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-owner-replacement-unresolved-config-"))
   const oldSocketPath = path.join(root, "old.sock")
   const newSocketPath = path.join(root, "new.sock")
@@ -1734,16 +1731,13 @@ test("config-changing owner replacement rejects an unresolved generation transit
     candidate = spawn(process.execPath, [binPath, "daemon", "--config", configPath, "--replace-owner"], {stdio: ["ignore", "pipe", "pipe"]})
     const result = await collectUntilExitOrLog(candidate, "owner replacement committed")
 
-    assert.equal(result.message, undefined, result.output)
-    assert.match(result.output, /config authority.*unresolved generation transition/i)
-    const status = await sendControlCommand({command: {command: "status"}, path: oldSocketPath})
-    const generationTransition = status.generationTransition
+    assert.equal(result.message, "owner replacement committed", result.output)
+    const status = await sendControlCommand({command: {command: "status"}, path: newSocketPath})
 
-    assert.ok(generationTransition && typeof generationTransition === "object" && !Array.isArray(generationTransition))
-    assert.equal(generationTransition.phase, "activating_candidate")
-    assert.match(String(generationTransition.error), /activate command exited non-zero/)
-    assert.equal(await fs.readFile(lifecycleLogPath, "utf8"), "activate:v1\nretire:v1\n")
-    const shutdown = sendControlCommand({command: {command: "shutdown"}, path: oldSocketPath})
+    assert.equal(status.activeReleaseId, "v1")
+    assert.equal(status.generationTransition, undefined)
+    assert.equal(await fs.readFile(lifecycleLogPath, "utf8"), "activate:v1\nretire:v1\nretire:v2\nactivate:v1\n")
+    const shutdown = sendControlCommand({command: {command: "shutdown"}, path: newSocketPath})
 
     await Promise.all([v1Path, v2Path].map((releasePath) => fs.writeFile(path.join(releasePath, "worker.fifo"), "drained\n")))
     await shutdown
@@ -1928,7 +1922,7 @@ async function removeDaemonRecoveryCapability(packagePath, {abortedPath, prepare
   const guardianPath = path.join(packagePath, "src", "process-guardian.js")
   const daemonPath = path.join(packagePath, "src", "daemon.js")
   const source = await fs.readFile(guardianPath, "utf8")
-  const capability = "  if (request.command === \"capabilities\") return {daemonRecovery: 1}\n\n"
+  const capability = "  if (request.command === \"capabilities\") return {daemonRecovery: 1, generationReactivation: 1}\n\n"
   const incumbentAbortNotification = "  if (ownerClient && !ownerClient.destroyed) ownerClient.write(`${JSON.stringify({event: \"replacement-aborted\", reason})}\\n`)\n"
   const legacyCapability = `  if (request.command === "capabilities") {
     while (!fsSync.existsSync(${JSON.stringify(preparedPath)})) await new Promise((resolve) => setTimeout(resolve, 5))