@gajae-gateway/cli 0.1.1 → 0.1.3

package/dist/main.js

@@ -2,9 +2,10 @@
 // @bun
 
 // src/main.ts
-import { copyFile, stat } from "fs/promises";
-import { isAbsolute, join as join2 } from "path";
-import { LOOPBACK_ORIGIN, originKey as originKey2, parseOriginKey } from "@gajae-gateway/protocol";
+import { Database } from "bun:sqlite";
+import { copyFile, lstat, readFile as readFile3, stat as stat2 } from "fs/promises";
+import { isAbsolute, join as join3 } from "path";
+import { LOOPBACK_ORIGIN, originKey as originKey2 } from "@gajae-gateway/protocol";
 import { GajaewayClient } from "@gajae-gateway/sdk";
 
 // src/list.ts
@@ -126,6 +127,12 @@ function renderList(columns, rows, options, envelope) {
   return [JSON.stringify({ ...envelope.result, [envelope.key]: projected })];
 }
 
+// src/restart-stack.ts
+import { randomUUID } from "crypto";
+import { access, mkdir as mkdir2, readFile as readFile2, rename, stat, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
 // src/services.ts
 import { chmod, mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
@@ -134,22 +141,34 @@ import { parseRuntimeConfig, RuntimeConfigError } from "@gajae-gateway/protocol"
 var CONFIG_SCHEMA_VERSION = 1;
 var FALLBACK_PATH_DIRS = ["/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"];
 var LOGIN_PATH_COMMAND = 'printf %s "$PATH"';
+var GATEWAY_UNIT = "gajaeway-gateway.service";
 var SERVICE_SPECS = [
-  { id: "gateway", label: "dev.gajaeway.gateway", binary: "gajaeway-gateway", args: ["daemon"] },
+  {
+    id: "gateway",
+    label: "dev.gajaeway.gateway",
+    binary: "gajaeway-gateway",
+    args: ["daemon"],
+    dependsOnGateway: false
+  },
   {
     id: "adapter-discord",
     label: "dev.gajaeway.adapter-discord",
     binary: "gajaeway-discord",
-    args: []
+    args: [],
+    dependsOnGateway: true
   },
   {
     id: "adapter-slack",
     label: "dev.gajaeway.adapter-slack",
     binary: "gajaeway-slack",
-    args: []
+    args: [],
+    dependsOnGateway: true
   },
-  { id: "admin", label: "dev.gajaeway.admin", binary: "gajaeway-admin", args: ["serve"] }
+  { id: "admin", label: "dev.gajaeway.admin", binary: "gajaeway-admin", args: ["serve"], dependsOnGateway: true }
 ];
+function serviceSpecs() {
+  return SERVICE_SPECS;
+}
 function homeForEnvironment(env) {
   return env.GAJAEWAY_HOME || join(env.HOME || homedir(), ".gajaeway");
 }
@@ -237,6 +256,70 @@ function renderLaunchAgent(spec, binDir, home, path) {
 </dict></plist>
 `;
 }
+function unitEnvironment(name, value) {
+  return `Environment="${name}=${value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
+}
+function systemdUnitName(spec) {
+  return `gajaeway-${spec.id}.service`;
+}
+function renderSystemdUnit(spec, binDir, home, path) {
+  const execStart = [join(binDir, spec.binary), ...spec.args].join(" ");
+  const unit = [
+    "[Unit]",
+    `Description=gajaeway ${spec.id}`,
+    ...spec.dependsOnGateway ? [`BindsTo=${GATEWAY_UNIT}`, `After=${GATEWAY_UNIT}`, `PartOf=${GATEWAY_UNIT}`] : [],
+    "",
+    "[Service]",
+    `ExecStart=${execStart}`,
+    `WorkingDirectory=${binDir}`,
+    unitEnvironment("GAJAEWAY_HOME", home),
+    unitEnvironment("PATH", path),
+    "Restart=always",
+    "RestartSec=2",
+    ...spec.dependsOnGateway ? [] : ["KillMode=process", "TimeoutStopSec=30s"],
+    "",
+    "[Install]",
+    `WantedBy=${spec.dependsOnGateway ? GATEWAY_UNIT : "default.target"}`,
+    ""
+  ];
+  return unit.join(`
+`);
+}
+function systemdUnitDir(env, userHome) {
+  const base = env.XDG_CONFIG_HOME || join(userHome, ".config");
+  return join(base, "systemd", "user");
+}
+function launchAgentPlistPath(spec, launchAgentsDir) {
+  return join(launchAgentsDir, `dev.gajaeway.${spec.id}.plist`);
+}
+function systemdUnitPath(spec, unitDir) {
+  return join(unitDir, systemdUnitName(spec));
+}
+function restartStackCommands(platform, uid) {
+  if (platform === "linux")
+    return [["systemctl", "--user", "restart", GATEWAY_UNIT]];
+  if (platform === "darwin") {
+    const target = uid ?? process.getuid?.() ?? 0;
+    return restartOrder().map((spec) => ["launchctl", "kickstart", "-k", `gui/${target}/${spec.label}`]);
+  }
+  throw new Error(`unsupported service platform: ${platform}`);
+}
+function restartOrder() {
+  return [
+    ...SERVICE_SPECS.filter((spec) => !spec.dependsOnGateway),
+    ...SERVICE_SPECS.filter((spec) => spec.dependsOnGateway)
+  ];
+}
+function requirePlatform(platform) {
+  if (platform !== "darwin" && platform !== "linux")
+    throw new Error(`unsupported service platform: ${platform}`);
+  return platform;
+}
+function currentPlatform() {
+  if (process.platform === "darwin" || process.platform === "linux")
+    return process.platform;
+  throw new Error(`unsupported service platform: ${process.platform}`);
+}
 async function readRuntime(home) {
   const configPath = join(home, "config.json");
   let raw;
@@ -267,10 +350,11 @@ async function installServices(options) {
   if (options.binDir.length === 0)
     throw new Error("services requires a non-empty --bin-dir DIR");
   const env = options.env ?? process.env;
+  const platform = options.platform === undefined ? currentPlatform() : requirePlatform(options.platform);
   const userHome = env.HOME || homedir();
   const home = homeForEnvironment(env);
   const binDir = expandHome(options.binDir, userHome);
-  const launchAgentsDir = expandHome(options.launchAgentsDir ?? join(userHome, "Library", "LaunchAgents"), userHome);
+  const targetDir = platform === "darwin" ? expandHome(options.launchAgentsDir ?? join(userHome, "Library", "LaunchAgents"), userHome) : expandHome(options.unitDir ?? systemdUnitDir(env, userHome), userHome);
   const runtime = await readRuntime(home);
   const path = await resolvePath({
     binDir,
@@ -279,24 +363,298 @@ async function installServices(options) {
     env,
     loginPathRunner: options.loginPathRunner
   });
-  await mkdir(launchAgentsDir, { recursive: true, mode: 448 });
-  const plists = SERVICE_SPECS.map((spec) => ({
-    path: join(launchAgentsDir, `dev.gajaeway.${spec.id}.plist`),
+  await mkdir(targetDir, { recursive: true, mode: 448 });
+  const definitions = SERVICE_SPECS.map((spec) => platform === "darwin" ? {
+    path: join(targetDir, `dev.gajaeway.${spec.id}.plist`),
     contents: renderLaunchAgent(spec, binDir, home, path)
-  }));
+  } : { path: join(targetDir, systemdUnitName(spec)), contents: renderSystemdUnit(spec, binDir, home, path) });
   const write = options.writeFile;
-  for (const plist of plists) {
+  for (const definition of definitions) {
     if (write)
-      await write(plist.path, plist.contents);
+      await write(definition.path, definition.contents);
     else {
-      await writeFile(plist.path, plist.contents, { encoding: "utf8", mode: 384 });
-      await chmod(plist.path, 384);
+      await writeFile(definition.path, definition.contents, { encoding: "utf8", mode: 384 });
+      await chmod(definition.path, 384);
     }
   }
-  return plists.map((plist) => plist.path);
+  return definitions.map((definition) => definition.path);
 }
 function serviceUsage() {
-  return "usage: gajaeway services install|repair --bin-dir DIR [--launch-agents-dir DIR]";
+  return "usage: gajaeway services install|repair --bin-dir DIR [--launch-agents-dir DIR] [--unit-dir DIR] [--platform darwin|linux]";
+}
+
+// src/restart-stack.ts
+var RECEIPT_FILE = "restart-stack.json";
+var VERIFY_TIMEOUT_MS = 90000;
+var POLL_MS = 1000;
+function restartReceiptPath(home) {
+  return join2(home, RECEIPT_FILE);
+}
+async function readRestartReceipt(home) {
+  let raw;
+  try {
+    raw = await readFile2(restartReceiptPath(home), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  return JSON.parse(raw);
+}
+async function writeReceipt(home, receipt) {
+  await mkdir2(home, { recursive: true });
+  const path = restartReceiptPath(home);
+  const temporary = `${path}.${process.pid}.tmp`;
+  await writeFile2(temporary, `${JSON.stringify(receipt, null, 2)}
+`, { mode: 384 });
+  await rename(temporary, path);
+}
+function newReceipt(id, platform, uid, now) {
+  const commands = restartStackCommands(platform, uid);
+  return {
+    id,
+    state: "queued",
+    platform,
+    requestedAt: new Date(now).toISOString(),
+    steps: restartOrder().map((spec, index) => ({
+      label: spec.label,
+      ...platform === "darwin" ? { command: commands[index] } : index === 0 ? { command: commands[0] } : {},
+      result: "pending"
+    }))
+  };
+}
+async function defaultCommandRunner(command) {
+  const child = Bun.spawn([...command], { stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+  return await child.exited;
+}
+async function capture(command) {
+  const child = Bun.spawn([...command], {
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "ignore",
+    env: { ...process.env, LC_ALL: "C" }
+  });
+  const output = await new Response(child.stdout).text();
+  return await child.exited === 0 ? output : undefined;
+}
+function defaultServiceProbe(platform) {
+  return async (label) => {
+    const spec = serviceSpecs().find((candidate) => candidate.label === label);
+    if (spec === undefined)
+      throw new Error(`unknown service label: ${label}`);
+    let pid;
+    if (platform === "darwin") {
+      const listed = await capture(["launchctl", "list", label]);
+      const match = listed?.match(/"PID"\s*=\s*(\d+);/);
+      pid = match ? Number(match[1]) : undefined;
+    } else {
+      const shown = await capture(["systemctl", "--user", "show", "-p", "MainPID", "--value", systemdUnitName(spec)]);
+      pid = shown === undefined ? undefined : Number(shown.trim());
+    }
+    if (pid === undefined || !Number.isInteger(pid) || pid <= 0)
+      return;
+    const lstart = await capture(["ps", "-o", "lstart=", "-p", String(pid)]);
+    const args = await capture(["ps", "-ww", "-o", "args=", "-p", String(pid)]);
+    if (lstart === undefined || args === undefined)
+      return;
+    const startedAt = Date.parse(lstart.trim());
+    if (!Number.isFinite(startedAt))
+      return;
+    const suffix = spec.args.length > 0 ? ` ${spec.args.join(" ")}` : "";
+    const line = args.trim();
+    const binary = suffix && line.endsWith(suffix) ? line.slice(0, -suffix.length) : line;
+    return { pid, startedAt, binary };
+  };
+}
+async function defaultBinaryModifiedAt(path) {
+  return (await stat(path)).mtimeMs;
+}
+function defaultIsServiceInstalled(options) {
+  return async (label) => {
+    const spec = serviceSpecs().find((s) => s.label === label);
+    if (spec === undefined)
+      return false;
+    if (options.platform === "darwin") {
+      const userHome2 = options.env.HOME || homedir2();
+      const agentsDir = options.launchAgentsDir || join2(userHome2, "Library", "LaunchAgents");
+      const plistPath = launchAgentPlistPath(spec, agentsDir);
+      try {
+        await access(plistPath);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    const userHome = options.env.HOME || homedir2();
+    const unitDirPath = options.unitDir || systemdUnitDir(options.env, userHome);
+    const unitPath = systemdUnitPath(spec, unitDirPath);
+    try {
+      await access(unitPath);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+}
+function floorSecond(ms) {
+  return Math.floor(ms / 1000) * 1000;
+}
+async function runRestartStack(options) {
+  const platform = options.platform ?? currentPlatform();
+  const runner = options.runner ?? defaultCommandRunner;
+  const probe = options.probe ?? defaultServiceProbe(platform);
+  const modifiedAt = options.binaryModifiedAt ?? defaultBinaryModifiedAt;
+  const isInstalled = options.isServiceInstalled ?? defaultIsServiceInstalled({
+    platform,
+    env: options.env ?? process.env,
+    launchAgentsDir: options.launchAgentsDir,
+    unitDir: options.unitDir
+  });
+  const now = options.now ?? Date.now;
+  const sleep = options.sleep ?? ((ms) => Bun.sleep(ms));
+  const timeoutMs = options.verifyTimeoutMs ?? VERIFY_TIMEOUT_MS;
+  const pollMs = options.pollMs ?? POLL_MS;
+  const existing = await readRestartReceipt(options.home);
+  const receipt = existing?.id === options.id && existing.state === "queued" ? existing : newReceipt(options.id, platform, options.uid, now());
+  receipt.state = "running";
+  receipt.supervisorPid = process.pid;
+  await writeReceipt(options.home, receipt);
+  let issuedAt = now();
+  for (const step of receipt.steps) {
+    if (receipt.state !== "running") {
+      step.result = "skipped";
+      continue;
+    }
+    try {
+      const installed = await isInstalled(step.label);
+      if (!installed) {
+        step.result = "skipped";
+        step.detail = "service is not installed";
+        await writeReceipt(options.home, receipt);
+        continue;
+      }
+      if (step.command !== undefined) {
+        issuedAt = now();
+        const status = await runner(step.command);
+        step.exitStatus = status;
+        if (status !== 0) {
+          step.result = "failed";
+          step.detail = `${step.command.join(" ")} exited with status ${status}`;
+        }
+      }
+      if (step.result === "pending")
+        await verifyStep(step, issuedAt);
+    } catch (error) {
+      step.result = "failed";
+      step.detail = error instanceof Error ? error.message : String(error);
+    }
+    if (step.result !== "ok" && step.result !== "skipped") {
+      receipt.state = step.result === "stale" ? "stale" : "failed";
+    }
+    await writeReceipt(options.home, receipt);
+  }
+  if (receipt.state === "running")
+    receipt.state = "ok";
+  receipt.finishedAt = new Date(now()).toISOString();
+  await writeReceipt(options.home, receipt);
+  return receipt;
+  async function verifyStep(step, since) {
+    const deadline = now() + timeoutMs;
+    for (;; ) {
+      const running = await probe(step.label);
+      let binaryModifiedAt = 0;
+      if (running !== undefined) {
+        binaryModifiedAt = await modifiedAt(running.binary);
+        step.pid = running.pid;
+        step.processStartedAt = new Date(running.startedAt).toISOString();
+        step.binary = running.binary;
+        step.binaryModifiedAt = new Date(binaryModifiedAt).toISOString();
+        if (running.startedAt >= floorSecond(Math.max(binaryModifiedAt, since))) {
+          step.result = "ok";
+          delete step.detail;
+          return;
+        }
+      }
+      if (now() >= deadline) {
+        if (running === undefined) {
+          step.result = "failed";
+          step.detail = "no running process after restart";
+        } else {
+          step.result = "stale";
+          step.detail = running.startedAt < binaryModifiedAt ? "process started before the deployed binary was modified" : "process was not restarted by this sequence";
+        }
+        return;
+      }
+      await sleep(pollMs);
+    }
+  }
+}
+function cliCommand() {
+  return Bun.main.startsWith("/$bunfs/") ? [process.execPath] : [process.execPath, Bun.main];
+}
+function alive(pid) {
+  if (pid === undefined)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function launchRestartStack(options) {
+  const platform = options.platform ?? currentPlatform();
+  const existing = await readRestartReceipt(options.home);
+  if (existing?.state === "running" && alive(existing.supervisorPid))
+    throw new Error(`restart-stack ${existing.id} is still running (supervisor pid ${existing.supervisorPid})`);
+  const receipt = newReceipt(randomUUID(), platform, options.uid, Date.now());
+  await writeReceipt(options.home, receipt);
+  const worker = [...options.worker ?? [...cliCommand(), "ops", "restart-stack"], "--run", receipt.id];
+  const child = Bun.spawn(supervisorArgv(platform, worker, options.home, receipt.id), {
+    detached: true,
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "ignore",
+    env: { ...options.env ?? process.env, GAJAEWAY_HOME: options.home }
+  });
+  child.unref();
+  return { receipt, supervisorPid: child.pid };
+}
+function supervisorArgv(platform, worker, home, id) {
+  if (platform === "darwin")
+    return [...worker];
+  return [
+    "systemd-run",
+    "--user",
+    "--collect",
+    "--quiet",
+    `--unit=gajaeway-restart-stack-${id}`,
+    `--setenv=GAJAEWAY_HOME=${home}`,
+    "--",
+    ...worker
+  ];
+}
+function effectiveRestartState(receipt) {
+  if (receipt.state === "running" && !alive(receipt.supervisorPid))
+    return "interrupted";
+  return receipt.state;
+}
+function renderRestartReceipt(receipt) {
+  const lines = [
+    `restart-stack ${receipt.id}: ${effectiveRestartState(receipt)}`,
+    `requestedAt: ${receipt.requestedAt}`,
+    `finishedAt: ${receipt.finishedAt ?? "-"}`
+  ];
+  for (const step of receipt.steps) {
+    const facts = [
+      step.pid === undefined ? undefined : `pid=${step.pid}`,
+      step.processStartedAt === undefined ? undefined : `started=${step.processStartedAt}`,
+      step.binaryModifiedAt === undefined ? undefined : `binary=${step.binaryModifiedAt}`,
+      step.detail
+    ].filter((fact) => fact !== undefined);
+    lines.push(`${step.label}: ${step.result}${facts.length > 0 ? ` ${facts.join(" ")}` : ""}`);
+  }
+  return lines;
 }
 
 // src/main.ts
@@ -315,7 +673,7 @@ var COMMANDS = [
   "work",
   "services"
 ];
-var CLI_USAGE = "usage: gajaeway [--socket PATH] status|shutdown|chat|daemon run|sessions list [--json] [--fields a,b,c] [--limit N] [--offset N]|sessions inspect <originKey-or-index>|memory audit|memory search <query>|monitors ...|work run|start <name> [--cwd DIR] [--resume] [--model ID|--preset NAME] [--notify originKey (start only)] <text>|work status <name>|work steer <name> <text>|work retire <name>|work jobs|ops backup <path>|ops cycle [--json]|ops integrity|ops restore <backupPath>|services install|repair --bin-dir DIR [--launch-agents-dir DIR] (work run waits for a response; caller timeout does not end the attempt)";
+var CLI_USAGE = "usage: gajaeway [--socket PATH] status|shutdown|chat|daemon run|sessions list [--json] [--fields a,b,c] [--limit N] [--offset N]|sessions inspect <originKey-or-index>|memory audit|memory search <query>|monitors ... (test <id> [--type T] [--payload J] [--wait[=SECONDS]])|work run|start <name> [--cwd DIR] [--resume] [--model ID|--preset NAME] <text>|work status <name>|work steer <name> <text>|work retire <name>|work jobs|ops backup <path>|ops redeliver <deliveryId>|ops redeliver --since <iso>|ops cycle [--json]|ops integrity|ops restore <backupPath>|ops restart-stack [--status]|services install|repair --bin-dir DIR [--launch-agents-dir DIR] [--unit-dir DIR] [--platform darwin|linux] (work run waits for a response; caller timeout does not end the attempt)";
 var USAGE_EXIT_CODE = 2;
 function usageFor(command) {
   return command !== undefined && COMMANDS.includes(command) ? undefined : CLI_USAGE;
@@ -340,22 +698,171 @@ function parseServicesArgs(args) {
     throw new Error(serviceUsage());
   let binDir;
   let launchAgentsDir;
+  let unitDir;
+  let platform;
   for (let i = 1;i < args.length; i++) {
     const flag = args[i];
-    if (flag === "--bin-dir" || flag === "--launch-agents-dir") {
+    if (flag === "--bin-dir" || flag === "--launch-agents-dir" || flag === "--unit-dir") {
       const value = args[++i];
       if (value === undefined || value.length === 0 || value.startsWith("--"))
         throw new Error(`${flag} expects a non-empty DIR`);
       if (flag === "--bin-dir")
         binDir = value;
+      else if (flag === "--unit-dir")
+        unitDir = value;
       else
         launchAgentsDir = value;
+    } else if (flag === "--platform") {
+      const value = args[++i];
+      if (value !== "darwin" && value !== "linux")
+        throw new Error("--platform expects darwin or linux");
+      platform = value;
     } else
       throw new Error(`unknown option: ${flag}`);
   }
   if (binDir === undefined)
     throw new Error("services requires --bin-dir DIR");
-  return { action, binDir, ...launchAgentsDir === undefined ? {} : { launchAgentsDir } };
+  return {
+    action,
+    binDir,
+    ...launchAgentsDir === undefined ? {} : { launchAgentsDir },
+    ...unitDir === undefined ? {} : { unitDir },
+    ...platform === undefined ? {} : { platform }
+  };
+}
+var MONITOR_UPDATE_USAGE = "usage: gajaeway monitors update <id> (--json '<partial MonitorSpec JSON>'|--schedule '<cron>' [--enabled true|false]|--enabled true|false [--schedule '<cron>'])";
+function parseMonitorUpdateArgs(args) {
+  const [monitorId, ...options] = args;
+  if (!monitorId || monitorId.startsWith("--") || options.length === 0)
+    throw new Error(MONITOR_UPDATE_USAGE);
+  let jsonPatch;
+  let schedule;
+  let enabled;
+  for (let i = 0;i < options.length; i++) {
+    const option = options[i];
+    if (option === "--json") {
+      const value = options[++i];
+      if (jsonPatch !== undefined || value === undefined || value.startsWith("--"))
+        throw new Error(MONITOR_UPDATE_USAGE);
+      let parsed;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+        throw new Error(MONITOR_UPDATE_USAGE);
+      }
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        throw new Error(MONITOR_UPDATE_USAGE);
+      jsonPatch = parsed;
+    } else if (option === "--schedule") {
+      const value = options[++i];
+      if (schedule !== undefined || !value || value.startsWith("--"))
+        throw new Error(MONITOR_UPDATE_USAGE);
+      schedule = value;
+    } else if (option === "--enabled") {
+      const value = options[++i];
+      if (enabled !== undefined || value !== "true" && value !== "false")
+        throw new Error(MONITOR_UPDATE_USAGE);
+      enabled = value === "true";
+    } else
+      throw new Error(MONITOR_UPDATE_USAGE);
+  }
+  if (jsonPatch !== undefined && (schedule !== undefined || enabled !== undefined))
+    throw new Error(MONITOR_UPDATE_USAGE);
+  if (jsonPatch !== undefined)
+    return { monitorId, params: { ...jsonPatch, monitorId } };
+  return {
+    monitorId,
+    params: {
+      monitorId,
+      ...schedule === undefined ? {} : { schedule },
+      ...enabled === undefined ? {} : { enabled }
+    }
+  };
+}
+var MONITOR_TEST_USAGE = "usage: gajaeway monitors test <id> [--type T] [--payload J] [--wait[=SECONDS]]";
+var MONITOR_WAIT_ERROR = `${MONITOR_TEST_USAGE}
+--wait expects a finite non-negative integer up to 86400`;
+function parseMonitorTestArgs(args) {
+  const [monitorId, ...flags] = args;
+  if (!monitorId || monitorId.startsWith("--"))
+    throw new Error(MONITOR_TEST_USAGE);
+  let eventType;
+  let payload = {};
+  let waitSeconds;
+  const seen = new Set;
+  for (let i = 0;i < flags.length; i++) {
+    const flag = flags[i];
+    if (flag === "--type" || flag === "--payload") {
+      if (seen.has(flag))
+        throw new Error(`${MONITOR_TEST_USAGE}
+duplicate ${flag}`);
+      seen.add(flag);
+      const value = flags[++i];
+      if (value === undefined || value.length === 0 || value.startsWith("--"))
+        throw new Error(`${MONITOR_TEST_USAGE}
+${flag} requires a value`);
+      if (flag === "--type")
+        eventType = value;
+      else
+        payload = JSON.parse(value);
+    } else if (flag === "--wait" || flag.startsWith("--wait=")) {
+      if (seen.has("--wait"))
+        throw new Error(`${MONITOR_TEST_USAGE}
+duplicate --wait`);
+      seen.add("--wait");
+      const value = flag === "--wait" ? undefined : flag.slice("--wait=".length);
+      if (value === undefined)
+        waitSeconds = 30;
+      else {
+        if (!/^\d+$/.test(value))
+          throw new Error(MONITOR_WAIT_ERROR);
+        const seconds = Number(value);
+        if (!Number.isFinite(seconds) || !Number.isInteger(seconds) || seconds > 86400)
+          throw new Error(MONITOR_WAIT_ERROR);
+        waitSeconds = seconds;
+      }
+    } else
+      throw new Error(`${MONITOR_TEST_USAGE}
+unknown argument: ${flag}`);
+  }
+  return {
+    monitorId,
+    ...eventType === undefined ? {} : { eventType },
+    payload,
+    ...waitSeconds === undefined ? {} : { waitSeconds }
+  };
+}
+var TERMINAL_MONITOR_STAGES = new Set(["delivered", "authored_no_delivery", "failed", "failed_no_retry"]);
+function waitForMonitorStage(client, eventId, timeoutSeconds) {
+  return new Promise((resolve) => {
+    let stage = "admitted";
+    let settled = false;
+    let timer;
+    let unsubscribe;
+    const finish = () => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      unsubscribe?.();
+      resolve(stage);
+    };
+    unsubscribe = client.on("monitor.event", (payload) => {
+      if (typeof payload !== "object" || payload === null)
+        return;
+      const event = payload;
+      if (event.eventId !== eventId || typeof event.stage !== "string")
+        return;
+      stage = event.stage;
+      if (TERMINAL_MONITOR_STAGES.has(stage))
+        finish();
+    });
+    if (settled)
+      unsubscribe();
+    else
+      timer = setTimeout(finish, timeoutSeconds * 1000);
+  });
 }
 function renderCycle(cycle) {
   const lines = [];
@@ -370,7 +877,14 @@ function renderCycle(cycle) {
   lines.push(`context: unread=${cycle.contextDiff.unread} expired=${cycle.contextDiff.expired} truncated=${cycle.contextDiff.truncated} omitted_oldest=${cycle.contextDiff.omittedOldestAt ?? "-"} omitted_newest=${cycle.contextDiff.omittedNewestAt ?? "-"}`);
   lines.push(`deliveries: pending=${cycle.deliveries.pending} inflight=${cycle.deliveries.inflight} confirmed=${cycle.deliveries.confirmed} failed_ambiguous=${cycle.deliveries.failedAmbiguous} expired=${cycle.deliveries.expired}`);
   lines.push(`memory: queued=${cycle.memoryIntents.queued} written=${cycle.memoryIntents.written} committed=${cycle.memoryIntents.committed} receipted=${cycle.memoryIntents.receipted} quarantined=${cycle.memoryIntents.quarantined}${cycle.memoryClosing ? " (closing)" : ""}`);
+  if (cycle.agentDisk) {
+    const { path, freeBytes, totalBytes } = cycle.agentDisk;
+    const gib = (bytes) => (bytes / 1024 ** 3).toFixed(1);
+    lines.push(freeBytes === null || totalBytes === null ? `agent_disk: ${path} unobservable` : `agent_disk: ${path} free=${gib(freeBytes)}GiB total=${gib(totalBytes)}GiB`);
+  }
   lines.push(`monitors: ${cycle.monitorEvents.length ? cycle.monitorEvents.map((m) => `${m.stage}=${m.count}`).join(" ") : "none"}`);
+  if (cycle.monitorAuthoringLost.length > 0)
+    lines.push(`monitor authoring lost: ${cycle.monitorAuthoringLost.map((m) => `${m.eventType}=${m.consecutive} (last ${m.lastFiredAt})`).join(" ")}`);
   if (cycle.sessions.length > 0) {
     lines.push("sessions:");
     lines.push("INDEX  ORIGIN                                      EPOCH  SESSION      PENDING  UNSETTLED  OLDEST");
@@ -385,11 +899,61 @@ function renderCycle(cycle) {
 function cycleExitCode(cycle) {
   return cycle.gates.length > 0 ? 1 : 0;
 }
+function verifyBackupIntegrity(backupPath) {
+  let database;
+  try {
+    database = new Database(backupPath, { readonly: true });
+  } catch (error) {
+    throw new Error(`Backup is not readable: ${backupPath} (${error instanceof Error ? error.message : String(error)})`);
+  }
+  let detail;
+  let pageCount;
+  try {
+    pageCount = database.query("PRAGMA page_count").get()?.page_count ?? 0;
+    detail = database.query("PRAGMA integrity_check").get()?.integrity_check ?? "unknown";
+  } catch (error) {
+    throw new Error(`Backup is not a readable SQLite database: ${backupPath} (${error instanceof Error ? error.message : String(error)})`);
+  } finally {
+    database.close();
+  }
+  if (pageCount === 0)
+    throw new Error(`Backup is an empty SQLite database: ${backupPath}`);
+  if (detail !== "ok")
+    throw new Error(`Backup failed SQLite integrity_check: ${backupPath} (${detail})`);
+}
+async function restoreTargetPath(home = gatewayHome()) {
+  const configPath = join3(home, "config.json");
+  let raw;
+  try {
+    raw = await readFile3(configPath, "utf8");
+  } catch (error) {
+    const code = error.code;
+    const entryExists = await lstat(configPath).then(() => true, () => false);
+    if (code !== "ENOENT" || entryExists)
+      throw new Error(`Cannot read ${configPath}; refusing restore.`);
+  }
+  if (raw === undefined)
+    return join3(home, "gateway.db");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Cannot parse ${configPath}; refusing restore.`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    throw new Error(`Invalid configuration ${configPath}: config must be an object; refusing restore.`);
+  const dbPath = parsed.dbPath;
+  if (dbPath === undefined)
+    return join3(home, "gateway.db");
+  if (typeof dbPath !== "string" || dbPath.length === 0)
+    throw new Error(`Invalid configuration ${configPath}: dbPath must be a non-empty string; refusing restore.`);
+  return dbPath;
+}
 async function restoreDatabase(socket, backupPath) {
   if (!isAbsolute(backupPath))
     throw new Error("ops restore requires an absolute backup path");
   try {
-    await stat(socket);
+    await stat2(socket);
     throw new Error(`Refusing restore: gateway socket ${socket} exists. Stop the daemon before restoring.`);
   } catch (error) {
     if (error instanceof Error && error.message.startsWith("Refusing restore:"))
@@ -397,15 +961,8 @@ async function restoreDatabase(socket, backupPath) {
     if (error.code !== "ENOENT")
       throw new Error(`Cannot verify gateway socket ${socket}; refusing restore.`);
   }
-  let header;
-  try {
-    header = new Uint8Array(await Bun.file(backupPath).slice(0, 16).arrayBuffer());
-  } catch {
-    throw new Error(`Backup is not readable: ${backupPath}`);
-  }
-  if (new TextDecoder().decode(header) !== "SQLite format 3\x00")
-    throw new Error(`Backup is not a SQLite database: ${backupPath}`);
-  const databasePath = join2(gatewayHome(), "gateway.db");
+  verifyBackupIntegrity(backupPath);
+  const databasePath = await restoreTargetPath();
   const preservedPath = `${databasePath}.pre-restore-${new Date().toISOString().replace(/[:.]/g, "-")}`;
   await copyFile(databasePath, preservedPath);
   await copyFile(backupPath, databasePath);
@@ -413,6 +970,7 @@ async function restoreDatabase(socket, backupPath) {
   console.log(`Copied current database to: ${preservedPath}`);
   console.log(`Restored backup to: ${databasePath}`);
 }
+var CHAT_TURN_TIMEOUT_MS = 30 * 60000;
 async function chat(socket) {
   let client;
   try {
@@ -437,9 +995,9 @@ async function chat(socket) {
     await new Promise((resolve) => {
       const timer = setTimeout(() => {
         turnWaiters.delete(turnId);
-        console.error("(turn timed out after 120s)");
+        console.error(`(turn timed out after ${CHAT_TURN_TIMEOUT_MS / 60000}m)`);
         resolve();
-      }, 120000);
+      }, CHAT_TURN_TIMEOUT_MS);
       turnWaiters.set(turnId, () => {
         clearTimeout(timer);
         turnWaiters.delete(turnId);
@@ -549,10 +1107,51 @@ async function main(args = process.argv.slice(2), options = {}) {
           await restoreDatabase(parsed.socket, path);
           break;
         }
+        if (command === "restart-stack") {
+          const usage2 = "usage: gajaeway ops restart-stack [--status]";
+          const home = gatewayHome();
+          const flag = parsed.rest[1];
+          if (flag === "--run" && parsed.rest.length === 3 && parsed.rest[2]) {
+            const receipt = await runRestartStack({
+              ...options.restartStack?.run,
+              home,
+              id: parsed.rest[2]
+            });
+            for (const line of renderRestartReceipt(receipt))
+              console.log(line);
+            if (receipt.state !== "ok")
+              process.exitCode = 1;
+          } else if (flag === "--status" && parsed.rest.length === 2) {
+            const receipt = await readRestartReceipt(home);
+            if (receipt === undefined)
+              throw new Error("no restart-stack receipt");
+            for (const line of renderRestartReceipt(receipt))
+              console.log(line);
+            if (effectiveRestartState(receipt) !== "ok")
+              process.exitCode = 1;
+          } else if (parsed.rest.length === 1) {
+            const { receipt, supervisorPid } = await launchRestartStack({ ...options.restartStack?.launch, home });
+            console.log(`restart-stack ${receipt.id}: queued (supervisor pid ${supervisorPid})`);
+            console.log("read the outcome with: gajaeway ops restart-stack --status");
+          } else
+            throw new Error(usage2);
+          break;
+        }
+        let redeliverParams;
+        if (command === "redeliver") {
+          if (parsed.rest.length === 2 && path && path !== "--since")
+            redeliverParams = { deliveryId: path };
+          else if (parsed.rest.length === 3 && path === "--since" && parsed.rest[2] && Number.isFinite(Date.parse(parsed.rest[2])))
+            redeliverParams = { since: parsed.rest[2] };
+          else
+            throw new Error("usage: gajaeway ops redeliver <deliveryId>|--since <iso>");
+        }
         const client = await GajaewayClient.connectSocket(parsed.socket);
         try {
           if (command === "backup" && path)
             console.log(JSON.stringify(await client.request("ops.backup", { path })));
+          else if (redeliverParams)
+            console.log(JSON.stringify(await client.request("ops.redeliver", redeliverParams)));
           else if (command === "integrity")
             console.log(JSON.stringify(await client.request("ops.integrity")));
           else if (command === "cycle") {
@@ -566,7 +1165,7 @@ async function main(args = process.argv.slice(2), options = {}) {
                 console.log(line);
             process.exitCode = cycleExitCode(cycle);
           } else
-            throw new Error("usage: gajaeway ops backup <path>|cycle [--json]|integrity|restore <backupPath>");
+            throw new Error("usage: gajaeway ops backup <path>|redeliver <deliveryId>|redeliver --since <iso>|cycle [--json]|integrity|restore <backupPath>|restart-stack [--status]");
         } finally {
           await client.close();
         }
@@ -595,12 +1194,16 @@ async function main(args = process.argv.slice(2), options = {}) {
         break;
       }
       case "monitors": {
-        const listOptions = parsed.rest[0] === "list" ? parseListOptions(parsed.rest.slice(1), MONITOR_COLUMNS) : undefined;
+        const [command, ...args2] = parsed.rest;
+        const listOptions = command === "list" ? parseListOptions(args2, MONITOR_COLUMNS) : undefined;
+        const update = command === "update" ? parseMonitorUpdateArgs(args2) : undefined;
+        const monitorTest = command === "test" ? parseMonitorTestArgs(args2) : undefined;
         const client = await GajaewayClient.connectSocket(parsed.socket);
         try {
-          const [command, ...args2] = parsed.rest;
           if (command === "add" && args2[0] === "--json" && args2[1])
             console.log(JSON.stringify(await client.request("monitor.add", JSON.parse(args2[1]))));
+          else if (command === "update" && update)
+            console.log(JSON.stringify(await client.request("monitor.update", update.params)));
           else if (command === "list") {
             const options2 = listOptions;
             const result = await client.request("monitor.list");
@@ -613,22 +1216,20 @@ async function main(args = process.argv.slice(2), options = {}) {
             console.log(JSON.stringify(await client.request("monitor.inspect", { monitorId: args2[0] })));
           else if (command === "remove" && args2[0])
             console.log(JSON.stringify(await client.request("monitor.remove", { monitorId: args2[0] })));
-          else if (command === "test" && args2[0]) {
-            let eventType;
-            let payload = {};
-            for (let i = 1;i < args2.length; i++) {
-              if (args2[i] === "--type")
-                eventType = args2[++i];
-              else if (args2[i] === "--payload")
-                payload = JSON.parse(args2[++i] ?? "");
+          else if (command === "test" && monitorTest) {
+            const result = await client.request("monitor.test", {
+              monitorId: monitorTest.monitorId,
+              ...monitorTest.eventType === undefined ? {} : { eventType: monitorTest.eventType },
+              payload: monitorTest.payload
+            });
+            if (monitorTest.waitSeconds === undefined)
+              console.log(JSON.stringify(result));
+            else {
+              const stage = await waitForMonitorStage(client, result.eventId, monitorTest.waitSeconds);
+              console.log(JSON.stringify({ eventId: result.eventId, stage }));
             }
-            console.log(JSON.stringify(await client.request("monitor.test", {
-              monitorId: args2[0],
-              ...eventType ? { eventType } : {},
-              payload
-            })));
           } else
-            throw new Error(`usage: gajaeway monitors add --json '<MonitorSpec json>'|list [--json] [--fields ${columnNames(MONITOR_COLUMNS).join(",")}] [--limit N] [--offset N]|inspect <id>|remove <id>|test <id> [--type T] [--payload J]`);
+            throw new Error(`usage: gajaeway monitors add --json '<MonitorSpec json>'|update <id> (--json '<partial MonitorSpec JSON>'|--schedule '<cron>' [--enabled true|false]|--enabled true|false [--schedule '<cron>'])|list [--json] [--fields ${columnNames(MONITOR_COLUMNS).join(",")}] [--limit N] [--offset N]|inspect <id>|remove <id>|test <id> [--type T] [--payload J] [--wait[=SECONDS]]`);
         } finally {
           await client.close();
         }
@@ -636,7 +1237,7 @@ async function main(args = process.argv.slice(2), options = {}) {
       }
       case "work": {
         const [command, ...args2] = parsed.rest;
-        const usage2 = 'usage: gajaeway work run|start <name> [--cwd DIR] [--resume] [--model ID|--preset NAME] [--notify originKey (start only)] "<task text>"|status <name>|steer <name> <text>|retire <name>|jobs';
+        const usage2 = 'usage: gajaeway work run|start <name> [--cwd DIR] [--resume] [--model ID|--preset NAME] "<task text>"|status <name>|steer <name> <text>|retire <name>|jobs';
         if (command === "status" || command === "steer") {
           const name2 = args2[0];
           const text2 = args2.slice(1).join(" ").trim();
@@ -670,7 +1271,8 @@ async function main(args = process.argv.slice(2), options = {}) {
               for (const job of result.jobs) {
                 const name2 = job.lane_key.startsWith("work-") ? job.lane_key.slice("work-".length) : job.lane_key;
                 const state = job.quarantined ? `HELD: quarantined reason=${job.reason} historical_state=${job.state}` : job.state;
-                console.log(`${name2} ${state} session=${job.session_id || "-"} last=${job.last_activity_at || "-"} ${job.worktree_path}`);
+                const head = job.last_commit ? `${job.last_commit.sha.slice(0, 7)}@${job.last_commit.committed_at} ${JSON.stringify(job.last_commit.subject)}` : "-";
+                console.log(`${name2} ${state} session=${job.session_id || "-"} accepted=${job.accepted_at || "-"} op=${job.attempt?.op_ref || "-"} last=${job.last_activity_at || "-"} head=${head} ${job.worktree_path}${job.reports && (job.reports.pending !== 0 || job.reports.claimed !== 0 || job.reports.held !== 0 || job.reports.undeliverable !== 0) ? ` reports=p:${job.reports.pending} c:${job.reports.claimed} h:${job.reports.held} u:${job.reports.undeliverable}` : ""}`);
               }
             }
           } finally {
@@ -684,11 +1286,10 @@ async function main(args = process.argv.slice(2), options = {}) {
         let cwd;
         let resume = false;
         let model;
-        let notify;
         const textParts = [];
         for (let i = 1;i < args2.length; i++) {
           const arg = args2[i];
-          if (arg === "--cwd" || arg === "--model" || arg === "--preset" || arg === "--notify") {
+          if (arg === "--cwd" || arg === "--model" || arg === "--preset") {
             const value = args2[++i];
             if (!value?.trim() || value.startsWith("--"))
               throw new Error(usage2);
@@ -696,15 +1297,6 @@ async function main(args = process.argv.slice(2), options = {}) {
               if (cwd !== undefined || !isAbsolute(value))
                 throw new Error(usage2);
               cwd = value;
-            } else if (arg === "--notify") {
-              if (command !== "start" || notify !== undefined)
-                throw new Error(usage2);
-              try {
-                notify = parseOriginKey(value);
-              } catch {
-                throw new Error(`${usage2}
-invalid --notify originKey`);
-              }
             } else {
               if (model !== undefined)
                 throw new Error(`${usage2}
@@ -725,13 +1317,14 @@ invalid --notify originKey`);
           requestTimeoutMs: command === "run" ? 3600000 : 120000
         });
         try {
+          const callerSessionId = process.env.GJC_SESSION_ID?.trim();
           const params = {
             name,
             text,
             ...cwd ? { cwd } : {},
             ...resume ? { resume: true } : {},
             ...model === undefined ? {} : { model },
-            ...notify === undefined ? {} : { notify }
+            ...callerSessionId ? { callerSessionId } : {}
           };
           if (command === "start") {
             const result = await client.request("work.start", params);
@@ -761,10 +1354,14 @@ job: ${result.jobId} state: ${result.state}`);
         const written = await installServices({
           binDir: service.binDir,
           ...service.launchAgentsDir === undefined ? {} : { launchAgentsDir: service.launchAgentsDir },
+          ...service.unitDir === undefined ? {} : { unitDir: service.unitDir },
+          ...service.platform === undefined ? {} : { platform: service.platform },
           env: process.env,
           ...options.services
         });
-        console.log(`services ${service.action}: wrote ${written.length} LaunchAgent plists`);
+        console.log(`services ${service.action}: wrote ${written.length} service definitions`);
+        for (const definition of written)
+          console.log(definition);
         break;
       }
       default:
@@ -787,6 +1384,8 @@ export {
   parseServicesArgs,
   renderCycle,
   restoreDatabase,
+  restoreTargetPath,
   socketPath,
-  usageFor
+  usageFor,
+  verifyBackupIntegrity
 };