arisa 5.1.60 → 5.1.65

package/README.md

@@ -61,6 +61,11 @@ The result is a toolset shaped by how you actually use the assistant, not by def
 - while a chat is busy, concurrent text steers Pi's active run by default
 - set `telegram.busyMessageMode` to `"queue"` to keep concurrent text messages in order; override one chat with `telegram.chatMeta[chatId].busyMessageMode`
 - media and normalized audio stay queued, and failed steering falls back to the ordered queue
+- an owner-workspace General topic may route only the assistant's visible reply to a matching topic; the incoming message and General session remain unchanged, and ambiguous replies stay in General
+- reply classification never runs in private chats or outside General
+- each owner workspace keeps a dynamic, chat-scoped topic registry; Arisa learns topic creation, rename, close, and reopen events, and records the context of topics it creates or initializes
+- when a substantial theme recurs in General without a matching topic, Arisa may occasionally propose a new one; creation still requires explicit user confirmation
+- legacy `replyTopics` configuration is imported once into the dynamic registry and then removed
 
 ### Tool model
 No tools ship with the core. All installed tools live under `~/.arisa/tools/<tool-name>`, whether they come from the [official catalog](https://github.com/clasen/Arisa/tree/main/tools), from another source the user chooses, or are created by the agent itself.
@@ -176,6 +181,10 @@ arisa --silent           # run without verbose logs
 
 Authorized Telegram chats can run the same safe service lifecycle with `/restart`.
 
+Background mode runs the Telegram/Pi worker under a lightweight supervisor. Unexpected worker exits use bounded exponential restart backoff. Scheduled agent tasks are serialized FIFO per conversation while different conversations remain independent; execution deadlines default to 15 minutes for scheduled prompts and 5 minutes for agent events. A timed-out turn is marked outcome-uncertain and is never replayed automatically. These policies can be overridden with `service.workerRestart*` and `tasks.*TimeoutMs` in the Arisa config.
+
+Tools may declare weighted execution resources in their manifest, for example `"execution": { "resourceClass": "browser", "weight": 1 }`. Runs sharing a declared class queue fairly once they reach its capacity; undeclared lightweight tools remain unconstrained. The default capacity is two per declared class. Override it with `toolExecution.defaultCapacity`, `toolExecution.capacities`, and `toolExecution.maxQueuedPerClass`. Arisa logs queue waits and new worker RSS peaks for operational measurement.
+
 Runtime model override (current process only):
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "5.1.60",
+  "version": "5.1.65",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

package/src/core/agent/agent-manager.js

@@ -199,6 +199,16 @@ export class AgentManager {
     this.sessionLifecycle.closeCached(String(chatId));
   }
 
+  async abortSession(chatId) {
+    const sessionKey = String(chatId);
+    const context = this.sessions.get(sessionKey);
+    try {
+      await context?.session?.abort?.();
+    } finally {
+      await this.sessionLifecycle.closeCached(sessionKey);
+    }
+  }
+
   getRuntimeDiagnostic() {
     return this.sessionLifecycle.getDiagnostic();
   }

package/src/core/config/config-defaults.js

@@ -16,6 +16,12 @@ export const daemonConfigDefaults = Object.freeze({
   ipcFrameBytes: 1_048_576
 });
 
+export const toolExecutionConfigDefaults = Object.freeze({
+  defaultCapacity: 2,
+  maxQueuedPerClass: 100,
+  capacities: Object.freeze({})
+});
+
 export const telegramConfigDefaults = Object.freeze({
   modelPickerPageSize: 8,
   busyMessageMode: "steer",
@@ -37,7 +43,16 @@ export const cliLogConfig = Object.freeze({
 
 export const serviceConfigDefaults = Object.freeze({
   shutdownTimeoutMs: 15_000,
-  shutdownPollIntervalMs: 100
+  shutdownPollIntervalMs: 100,
+  workerRestartLimit: 3,
+  workerRestartBackoffMs: 2_000,
+  workerRestartBackoffMaxMs: 60_000,
+  workerStableRuntimeMs: 60_000
+});
+
+export const taskConfigDefaults = Object.freeze({
+  agentTimeoutMs: 15 * 60_000,
+  eventTimeoutMs: 5 * 60_000
 });
 
 export const piConfigDefaults = Object.freeze({
@@ -70,6 +85,14 @@ export function applyConfigDefaults(config) {
       ...telegramConfigDefaults,
       ...(config.telegram || {})
     },
+    toolExecution: {
+      ...toolExecutionConfigDefaults,
+      ...(config.toolExecution || {}),
+      capacities: {
+        ...toolExecutionConfigDefaults.capacities,
+        ...(config.toolExecution?.capacities || {})
+      }
+    },
     doctor: {
       ...doctorConfigDefaults,
       ...(config.doctor || {})
@@ -78,6 +101,10 @@ export function applyConfigDefaults(config) {
       ...serviceConfigDefaults,
       ...(config.service || {})
     },
+    tasks: {
+      ...taskConfigDefaults,
+      ...(config.tasks || {})
+    },
     pi: {
       ...piConfigDefaults,
       ...configuredPi,

package/src/core/tasks/task-runner.js

@@ -10,7 +10,7 @@ export class NonRetryableTaskError extends Error {
   }
 }
 
-export function createTaskRunner({ taskStore, dispatch, onTerminalFailure, logger, claimLimit = 10 }) {
+export function createTaskRunner({ taskStore, dispatch, laneKey = (task) => task.id, onTerminalFailure, logger, claimLimit = 10 }) {
   if (!taskStore || typeof dispatch !== "function") {
     throw new Error("Task runner requires taskStore and dispatch");
   }
@@ -27,8 +27,11 @@ export function createTaskRunner({ taskStore, dispatch, onTerminalFailure, logge
     }
   }
 
-  async function runClaimedTask(task) {
+  const lanes = new Map();
+
+  async function executeClaimedTask(task) {
     try {
+      await taskStore.markExecutionStarted?.(task.id);
       await dispatch(task);
       await taskStore.complete(task.id);
       logger?.log("tasks", `task ${task.id} completed after confirmed execution`);
@@ -44,6 +47,18 @@ export function createTaskRunner({ taskStore, dispatch, onTerminalFailure, logge
     }
   }
 
+  function runClaimedTask(task) {
+    const key = String(laneKey(task));
+    const previous = lanes.get(key) || Promise.resolve();
+    const running = previous.catch(() => {}).then(() => executeClaimedTask(task));
+    lanes.set(key, running);
+    running.then(
+      () => { if (lanes.get(key) === running) lanes.delete(key); },
+      () => { if (lanes.get(key) === running) lanes.delete(key); }
+    );
+    return running;
+  }
+
   async function dispatchDueTasks() {
     const tasks = await taskStore.claimDue(claimLimit);
     return Promise.all(tasks.map(runClaimedTask));

package/src/core/tasks/task-store.js

@@ -144,6 +144,9 @@ function normalizeTask(task, defaults = {}) {
       ...(defaults.source || {}),
       ...(task.source || {})
     },
+    ...(task.startedAt ? { startedAt: task.startedAt } : {}),
+    ...(task.claimedAt ? { claimedAt: task.claimedAt } : {}),
+    ...(task.executionStartedAt ? { executionStartedAt: task.executionStartedAt } : {}),
     attempts: task.attempts || 0,
     retry: task.retry || defaults.retry
   });
@@ -228,21 +231,37 @@ export class TaskStore {
   async claimDue(limit = 10) {
     return this.mutate(async (tasks) => {
       const now = Date.now();
-      const due = [];
-
-      for (const task of tasks) {
-        if (due.length >= limit) break;
-        if (task.status !== "pending") continue;
-        if (!task.runAt || Number.isNaN(Date.parse(task.runAt))) continue;
-        if (Date.parse(task.runAt) > now) continue;
+      const due = tasks
+        .filter((task) => task.status === "pending"
+          && task.runAt
+          && !Number.isNaN(Date.parse(task.runAt))
+          && Date.parse(task.runAt) <= now)
+        .sort((left, right) => Date.parse(left.runAt) - Date.parse(right.runAt)
+          || Date.parse(left.createdAt || 0) - Date.parse(right.createdAt || 0)
+          || String(left.id).localeCompare(String(right.id)))
+        .slice(0, limit);
+
+      const claimedAt = new Date(now).toISOString();
+      for (const task of due) {
         task.status = "running";
         task.attempts += 1;
-        task.startedAt = new Date(now).toISOString();
-        task.updatedAt = task.startedAt;
-        due.push(structuredClone(task));
+        task.startedAt = claimedAt;
+        task.claimedAt = claimedAt;
+        delete task.executionStartedAt;
+        task.updatedAt = claimedAt;
       }
 
-      return { result: due, changed: due.length > 0 };
+      return { result: structuredClone(due), changed: due.length > 0 };
+    });
+  }
+
+  async markExecutionStarted(taskId) {
+    return this.mutate(async (tasks) => {
+      const task = tasks.find((item) => item.id === taskId);
+      if (!task || task.status !== "running") return { result: null, changed: false };
+      task.executionStartedAt = new Date().toISOString();
+      task.updatedAt = task.executionStartedAt;
+      return { result: structuredClone(task) };
     });
   }
 
@@ -255,12 +274,29 @@ export class TaskStore {
       for (const task of tasks) {
         if (task.status === "running") {
           const interruptedAt = new Date(now).toISOString();
+          if (task.claimedAt && !task.executionStartedAt) {
+            task.status = "pending";
+            task.attempts = Math.max(0, Number(task.attempts || 0) - 1);
+            task.lastError = "execution interrupted before start";
+            task.lastFailedAt = interruptedAt;
+            task.updatedAt = interruptedAt;
+            task.lastClaimedAt = task.claimedAt;
+            delete task.startedAt;
+            delete task.claimedAt;
+            recovered.push(structuredClone(task));
+            continue;
+          }
           task.lastError = "execution interrupted before confirmation";
           task.lastFailedAt = interruptedAt;
           task.updatedAt = interruptedAt;
+          if (task.claimedAt) task.lastClaimedAt = task.claimedAt;
+          if (task.executionStartedAt) task.lastExecutionStartedAt = task.executionStartedAt;
+          delete task.claimedAt;
+          delete task.executionStartedAt;
           if (task.kind === "poll_tool") {
             task.status = "pending";
             task.runAt = new Date(now + retryDelayMs(task)).toISOString();
+            delete task.startedAt;
           } else {
             const nextRunAt = computeNextRunAt(task, now);
             if (nextRunAt) {
@@ -268,6 +304,7 @@ export class TaskStore {
               task.runAt = nextRunAt;
               task.attempts = 0;
               task.lastOutcome = "outcome_uncertain";
+              delete task.startedAt;
             } else {
               task.status = "outcome_uncertain";
               task.error = task.lastError;
@@ -294,10 +331,14 @@ export class TaskStore {
       const nextRunAt = computeNextRunAt(task, now);
       task.lastCompletedAt = completedAt;
       task.lastRunAt = completedAt;
+      if (task.claimedAt) task.lastClaimedAt = task.claimedAt;
+      if (task.executionStartedAt) task.lastExecutionStartedAt = task.executionStartedAt;
       delete task.lastError;
       delete task.error;
       delete task.lastOutcome;
       delete task.consecutiveFailures;
+      delete task.claimedAt;
+      delete task.executionStartedAt;
       if (nextRunAt) {
         task.status = "pending";
         task.runAt = nextRunAt;
@@ -319,12 +360,28 @@ export class TaskStore {
       if (!task) return { result: null, changed: false };
       const message = error instanceof Error ? error.message : String(error);
       if (outcomeUncertain) {
-        const uncertainAt = new Date().toISOString();
+        const now = Date.now();
+        const uncertainAt = new Date(now).toISOString();
+        const nextRunAt = computeNextRunAt(task, now);
+        task.lastError = message;
+        task.lastFailedAt = uncertainAt;
+        task.updatedAt = uncertainAt;
+        if (task.claimedAt) task.lastClaimedAt = task.claimedAt;
+        if (task.executionStartedAt) task.lastExecutionStartedAt = task.executionStartedAt;
+        delete task.claimedAt;
+        delete task.executionStartedAt;
+        if (nextRunAt) {
+          task.status = "pending";
+          task.runAt = nextRunAt;
+          task.attempts = 0;
+          task.lastOutcome = "outcome_uncertain";
+          delete task.startedAt;
+          delete task.error;
+          return { result: { ...structuredClone(task), terminalFailure: true } };
+        }
         task.status = "outcome_uncertain";
         task.error = message;
-        task.lastError = message;
         task.uncertainAt = uncertainAt;
-        task.updatedAt = uncertainAt;
         compactTerminalTask(task);
         return { result: structuredClone(task) };
       }
@@ -343,7 +400,11 @@ export class TaskStore {
         task.lastFailedAt = failedAt;
         task.consecutiveFailures = Number(task.consecutiveFailures || 0) + 1;
         task.updatedAt = failedAt;
+        if (task.claimedAt) task.lastClaimedAt = task.claimedAt;
+        if (task.executionStartedAt) task.lastExecutionStartedAt = task.executionStartedAt;
         delete task.startedAt;
+        delete task.claimedAt;
+        delete task.executionStartedAt;
         delete task.error;
         return { result: { ...structuredClone(task), terminalFailure: true } };
       }
@@ -354,6 +415,11 @@ export class TaskStore {
       task.lastError = message;
       task.lastFailedAt = new Date(now).toISOString();
       task.updatedAt = task.lastFailedAt;
+      if (task.claimedAt) task.lastClaimedAt = task.claimedAt;
+      if (task.executionStartedAt) task.lastExecutionStartedAt = task.executionStartedAt;
+      delete task.startedAt;
+      delete task.claimedAt;
+      delete task.executionStartedAt;
       return { result: structuredClone(task) };
     });
   }

package/src/core/tools/tool-registry.js

@@ -11,6 +11,7 @@ import { daemonConfigDefaults } from "../config/config-defaults.js";
 import { SkillRegistry } from "../skills/skill-registry.js";
 import { ToolUsageStore } from "./tool-usage-store.js";
 import { inspectToolDependencies, normalizeToolDependencies } from "./tool-dependencies.js";
+import { normalizeToolExecution, WeightedResourceGovernor } from "./weighted-resource-governor.js";
 
 function toolEnv() {
   return { ...process.env, ARISA_PACKAGE_DIR: arisaPackageDir, ARISA_IPC_SOCKET: arisaIpcSocketFile };
@@ -272,7 +273,9 @@ export class ToolRegistry {
     resolveOfficialToolNames = readOfficialToolNames,
     helpTimeoutMs = defaultToolHelpTimeoutMs,
     runTimeoutMs = defaultToolRunTimeoutMs,
-    killGraceMs = defaultToolKillGraceMs
+    killGraceMs = defaultToolKillGraceMs,
+    executionPolicy,
+    executionGovernor
   } = {}) {
     this.logger = logger;
     this.helpTimeoutMs = positiveDuration(helpTimeoutMs, defaultToolHelpTimeoutMs);
@@ -282,6 +285,10 @@ export class ToolRegistry {
     this.skillRegistry = new SkillRegistry();
     this.usageStore = usageStore;
     this.resolveOfficialToolNames = resolveOfficialToolNames;
+    this.executionGovernor = executionGovernor || new WeightedResourceGovernor({
+      policy: executionPolicy,
+      logger
+    });
   }
 
   async buildSnapshot() {
@@ -308,6 +315,7 @@ export class ToolRegistry {
         snapshot.set(manifest.name, {
           ...manifest,
           toolDependencies: normalizeToolDependencies(manifest.toolDependencies),
+          execution: normalizeToolExecution(manifest.execution),
           category: normalizeCategory(manifest.category),
           keywords: normalizeKeywords(manifest.keywords),
           skillHints,
@@ -450,6 +458,10 @@ export class ToolRegistry {
     return inspectToolDependencies(this.tools, name);
   }
 
+  executionDiagnostic() {
+    return this.executionGovernor.snapshot();
+  }
+
   async usage(chatId) {
     const [counts, officialNames] = await Promise.all([
       this.usageStore.counts(chatId),
@@ -475,14 +487,16 @@ export class ToolRegistry {
     await this.usageStore.record(chatId, name).catch((error) => {
       this.logger?.error("tools", `could not record ${name} usage: ${error?.message || String(error)}`);
     });
-    this.logger?.log("tools", `running ${name}`);
     const tmpDir = chatId != null ? getChatToolTmpDir(chatId, name) : getToolTmpDir(name);
-    await mkdir(tmpDir, { recursive: true });
     const requestFile = path.join(tmpDir, `.request-${Date.now()}-${randomUUID()}.json`);
-    const skills = await this.resolveSkills(name);
-    const enrichedRequest = { ...request, chatId, skills };
+    let lease = null;
     let result;
     try {
+      lease = await this.executionGovernor.acquire(tool.execution, name);
+      this.logger?.log("tools", `running ${name}`);
+      await mkdir(tmpDir, { recursive: true });
+      const skills = await this.resolveSkills(name);
+      const enrichedRequest = { ...request, chatId, skills };
       if (tool.daemon?.protocol === "arisa-daemon-v1") {
         const scope = tool.daemon.scope === "chat"
           ? { type: "chat", chatId }
@@ -538,6 +552,7 @@ export class ToolRegistry {
         error: error?.message || `Invalid tool response for ${name}`
       });
     } finally {
+      lease?.release();
       await unlink(requestFile).catch(() => {});
       await rmdir(tmpDir).catch(() => {});
       if (chatId != null) {

package/src/core/tools/weighted-resource-governor.js

@@ -0,0 +1,153 @@
+const defaultCapacity = 2;
+const defaultMaxQueuedPerClass = 100;
+
+function positiveInteger(value, fallback) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function resourceClassName(value) {
+  const name = String(value || "").trim();
+  if (!name) return "";
+  if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(name)) {
+    throw new Error(`Invalid tool execution resource class: ${name}`);
+  }
+  return name;
+}
+
+export function normalizeToolExecution(execution) {
+  if (execution == null) return null;
+  if (!execution || typeof execution !== "object" || Array.isArray(execution)) {
+    throw new Error("Tool execution policy must be an object");
+  }
+  const resourceClass = resourceClassName(execution.resourceClass);
+  if (!resourceClass) throw new Error("Tool execution resourceClass is required");
+  const weight = positiveInteger(execution.weight, 0);
+  if (!weight) throw new Error("Tool execution weight must be a positive integer");
+  return { resourceClass, weight };
+}
+
+export function normalizeToolExecutionPolicy(policy = {}) {
+  const configuredCapacities = policy?.capacities && typeof policy.capacities === "object" && !Array.isArray(policy.capacities)
+    ? policy.capacities
+    : {};
+  const capacities = {};
+  for (const [name, value] of Object.entries(configuredCapacities)) {
+    capacities[resourceClassName(name)] = positiveInteger(value, defaultCapacity);
+  }
+  return {
+    defaultCapacity: positiveInteger(policy?.defaultCapacity, defaultCapacity),
+    maxQueuedPerClass: positiveInteger(policy?.maxQueuedPerClass, defaultMaxQueuedPerClass),
+    capacities
+  };
+}
+
+function noopLease() {
+  return { waitedMs: 0, release() {} };
+}
+
+export class WeightedResourceGovernor {
+  constructor({ policy, logger, now = () => Date.now(), memoryUsage = () => process.memoryUsage() } = {}) {
+    this.policy = normalizeToolExecutionPolicy(policy);
+    this.logger = logger;
+    this.now = now;
+    this.memoryUsage = memoryUsage;
+    this.resources = new Map();
+    this.peakRssBytes = 0;
+    this.lastLoggedRssBytes = 0;
+  }
+
+  capacityFor(resourceClass) {
+    return this.policy.capacities[resourceClass] || this.policy.defaultCapacity;
+  }
+
+  stateFor(resourceClass) {
+    let state = this.resources.get(resourceClass);
+    if (!state) {
+      state = { activeWeight: 0, queue: [] };
+      this.resources.set(resourceClass, state);
+    }
+    return state;
+  }
+
+  observeMemory(resourceClass) {
+    const rss = Number(this.memoryUsage()?.rss) || 0;
+    if (rss <= this.peakRssBytes) return;
+    this.peakRssBytes = rss;
+    const logStepBytes = 8 * 1024 * 1024;
+    if (this.lastLoggedRssBytes && rss - this.lastLoggedRssBytes < logStepBytes) return;
+    this.lastLoggedRssBytes = rss;
+    this.logger?.log("tools", `worker RSS peak ${Math.ceil(rss / 1024 / 1024)} MiB while using ${resourceClass}`);
+  }
+
+  createLease(resourceClass, weight, waitedMs) {
+    let released = false;
+    return {
+      waitedMs,
+      release: () => {
+        if (released) return;
+        released = true;
+        const state = this.stateFor(resourceClass);
+        state.activeWeight = Math.max(0, state.activeWeight - weight);
+        this.observeMemory(resourceClass);
+        this.drain(resourceClass);
+      }
+    };
+  }
+
+  grant(resourceClass, request) {
+    const state = this.stateFor(resourceClass);
+    state.activeWeight += request.weight;
+    const waitedMs = Math.max(0, this.now() - request.queuedAt);
+    this.observeMemory(resourceClass);
+    if (waitedMs > 0) {
+      this.logger?.log("tools", `${request.label} acquired ${resourceClass} capacity after ${waitedMs}ms`);
+    }
+    request.resolve(this.createLease(resourceClass, request.weight, waitedMs));
+  }
+
+  drain(resourceClass) {
+    const state = this.stateFor(resourceClass);
+    const capacity = this.capacityFor(resourceClass);
+    while (state.queue.length) {
+      const next = state.queue[0];
+      if (state.activeWeight + next.weight > capacity) break;
+      state.queue.shift();
+      this.grant(resourceClass, next);
+    }
+  }
+
+  acquire(execution, label = "tool") {
+    if (!execution) return Promise.resolve(noopLease());
+    const resourceClass = execution.resourceClass;
+    const capacity = this.capacityFor(resourceClass);
+    const weight = Math.min(execution.weight, capacity);
+    const state = this.stateFor(resourceClass);
+    if (!state.queue.length && state.activeWeight + weight <= capacity) {
+      return new Promise((resolve) => this.grant(resourceClass, {
+        weight,
+        label,
+        queuedAt: this.now(),
+        resolve
+      }));
+    }
+    if (state.queue.length >= this.policy.maxQueuedPerClass) {
+      throw new Error(`Tool execution queue is full for resource class ${resourceClass}`);
+    }
+    this.logger?.log("tools", `${label} queued for ${resourceClass} capacity (${state.activeWeight}/${capacity})`);
+    return new Promise((resolve) => {
+      state.queue.push({ weight, label, queuedAt: this.now(), resolve });
+    });
+  }
+
+  snapshot() {
+    return {
+      peakRssBytes: this.peakRssBytes,
+      resources: Object.fromEntries([...this.resources.entries()].map(([name, state]) => [name, {
+        capacity: this.capacityFor(name),
+        activeWeight: state.activeWeight,
+        queued: state.queue.length
+      }]))
+    };
+  }
+}

package/src/index.js

@@ -5,6 +5,7 @@ import { applyRuntimeOverrides, createApp } from "./runtime/create-app.js";
 import { loadConfig } from "./core/config/config-store.js";
 import { createLogger } from "./runtime/logger.js";
 import { getServiceStatus, handoffServiceRestart, registerServiceProcess, restartService, serviceEntryFile, startService, stopService, unregisterServiceProcess } from "./runtime/service-manager.js";
+import { createServiceSupervisor } from "./runtime/service-supervisor.js";
 import { flushArisaHome } from "./runtime/flush.js";
 import { readPackageVersion, showServiceLogs } from "./runtime/log-viewer.js";
 import { arisaPackageDir } from "./runtime/paths.js";
@@ -19,6 +20,7 @@ const command = cli.positionals[0] || "run";
 const forceBootstrap = Boolean(cli.flags.bootstrap);
 const verbose = !cli.flags.silent;
 const serviceRunner = Boolean(cli.flags["service-runner"]);
+const serviceWorker = Boolean(cli.flags["service-worker"]);
 const slaveCommand = command === "slave";
 const slaveServiceRunner = slaveCommand && serviceRunner;
 const runtimeOverrides = toNestedOverrides(cli.nestedFlags);
@@ -233,6 +235,24 @@ async function main() {
 
   if (serviceRunner) {
     await registerServiceProcess();
+    const persistedConfig = await loadConfig();
+    const workerArgs = [serviceEntryFile, "--service-worker", ...toServiceRunnerArgs(cli.nestedFlags)];
+    if (!verbose) workerArgs.push("--silent");
+    const supervisor = createServiceSupervisor({
+      command: process.execPath,
+      args: workerArgs,
+      restartLimit: persistedConfig.service.workerRestartLimit,
+      restartBackoffMs: persistedConfig.service.workerRestartBackoffMs,
+      restartBackoffMaxMs: persistedConfig.service.workerRestartBackoffMaxMs,
+      stableRuntimeMs: persistedConfig.service.workerStableRuntimeMs,
+      logger
+    });
+    activeApp = supervisor;
+    await supervisor.start();
+    return;
+  }
+
+  if (serviceWorker) {
     await runForeground();
     return;
   }