nextclaw 0.6.8 → 0.6.10

package/dist/cli/index.js

@@ -9,7 +9,7 @@ import {
   loadConfig as loadConfig6,
   saveConfig as saveConfig5,
   getConfigPath as getConfigPath3,
-  getDataDir as getDataDir6,
+  getDataDir as getDataDir7,
   ConfigSchema as ConfigSchema2,
   getWorkspacePath as getWorkspacePath5,
   expandHome as expandHome2,
@@ -21,8 +21,8 @@ import {
   DEFAULT_WORKSPACE_PATH
 } from "@nextclaw/core";
 import { resolvePluginChannelMessageToolHints as resolvePluginChannelMessageToolHints2 } from "@nextclaw/openclaw-compat";
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
-import { join as join6, resolve as resolve8 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join6, resolve as resolve9 } from "path";
 import { createInterface as createInterface2 } from "readline";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { spawn as spawn3 } from "child_process";
@@ -255,7 +255,7 @@ async function waitForExit(pid, timeoutMs) {
     if (!isProcessRunning(pid)) {
       return true;
     }
-    await new Promise((resolve9) => setTimeout(resolve9, 200));
+    await new Promise((resolve10) => setTimeout(resolve10, 200));
   }
   return !isProcessRunning(pid);
 }
@@ -345,8 +345,8 @@ function printAgentResponse(response) {
 async function prompt(rl, question) {
   rl.setPrompt(question);
   rl.prompt();
-  return new Promise((resolve9) => {
-    rl.once("line", (line) => resolve9(line));
+  return new Promise((resolve10) => {
+    rl.once("line", (line) => resolve10(line));
   });
 }
 
@@ -894,8 +894,8 @@ var PluginCommands = class {
       input: process.stdin,
       output: process.stdout
     });
-    const answer = await new Promise((resolve9) => {
-      rl.question(`${question} [y/N] `, (line) => resolve9(line));
+    const answer = await new Promise((resolve10) => {
+      rl.question(`${question} [y/N] `, (line) => resolve10(line));
     });
     rl.close();
     const normalized = answer.trim().toLowerCase();
@@ -1720,17 +1720,17 @@ var DiagnosticsCommands = class {
     }
   }
   async checkPortAvailability(params) {
-    return await new Promise((resolve9) => {
+    return await new Promise((resolve10) => {
       const server = createNetServer();
       server.once("error", (error) => {
-        resolve9({
+        resolve10({
           available: false,
           detail: `bind failed on ${params.host}:${params.port} (${String(error)})`
         });
       });
       server.listen(params.port, params.host, () => {
         server.close(() => {
-          resolve9({
+          resolve10({
             available: true,
             detail: `bind ok on ${params.host}:${params.port}`
           });
@@ -1748,7 +1748,7 @@ import {
   CronService as CronService2,
   getApiBase,
   getConfigPath as getConfigPath2,
-  getDataDir as getDataDir4,
+  getDataDir as getDataDir5,
   getProvider,
   getProviderName,
   getWorkspacePath as getWorkspacePath4,
@@ -1768,26 +1768,126 @@ import {
   stopPluginChannelGateways
 } from "@nextclaw/openclaw-compat";
 import { startUiServer } from "@nextclaw/server";
-import { closeSync, mkdirSync as mkdirSync2, openSync } from "fs";
-import { join as join4, resolve as resolve6 } from "path";
+import { closeSync, mkdirSync as mkdirSync3, openSync } from "fs";
+import { join as join4, resolve as resolve7 } from "path";
 import { spawn as spawn2 } from "child_process";
 import chokidar from "chokidar";
 
 // src/cli/gateway/controller.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
 import {
   buildConfigSchema,
   ConfigSchema,
   redactConfigObject
 } from "@nextclaw/core";
+
+// src/cli/restart-sentinel.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve6 } from "path";
+import { getDataDir as getDataDir4 } from "@nextclaw/core";
+var RESTART_SENTINEL_FILENAME = "restart-sentinel.json";
+var PENDING_SYSTEM_EVENTS_KEY = "pending_system_events";
+function resolveRestartSentinelPath() {
+  return resolve6(getDataDir4(), "run", RESTART_SENTINEL_FILENAME);
+}
+async function writeRestartSentinel(payload) {
+  const path = resolveRestartSentinelPath();
+  mkdirSync2(resolve6(path, ".."), { recursive: true });
+  const file = {
+    version: 1,
+    payload
+  };
+  writeFileSync2(path, `${JSON.stringify(file, null, 2)}
+`, "utf-8");
+  return path;
+}
+async function consumeRestartSentinel() {
+  const path = resolveRestartSentinelPath();
+  if (!existsSync5(path)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync3(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.version !== 1 || !parsed.payload) {
+      rmSync2(path, { force: true });
+      return null;
+    }
+    rmSync2(path, { force: true });
+    return parsed;
+  } catch {
+    rmSync2(path, { force: true });
+    return null;
+  }
+}
+function summarizeRestartSentinel(payload) {
+  const reason = payload.stats?.reason?.trim();
+  if (payload.kind === "update.run") {
+    return payload.status === "ok" ? "\u2705 NextClaw update completed and service restarted." : "\u26A0\uFE0F NextClaw update finished with issues.";
+  }
+  if (payload.kind === "config.apply" || payload.kind === "config.patch") {
+    return payload.status === "ok" ? "\u2705 Config applied and service restarted." : "\u26A0\uFE0F Config change restart finished with issues.";
+  }
+  if (reason) {
+    return `Gateway restart complete (${reason}).`;
+  }
+  return "Gateway restart complete.";
+}
+function formatRestartSentinelMessage(payload) {
+  const lines = [summarizeRestartSentinel(payload)];
+  const note = payload.message?.trim();
+  if (note) {
+    lines.push(note);
+  }
+  const reason = payload.stats?.reason?.trim();
+  if (reason && !lines.some((line) => line.includes(reason))) {
+    lines.push(`Reason: ${reason}`);
+  }
+  return lines.join("\n");
+}
+function parseSessionKey(sessionKey) {
+  const value = sessionKey?.trim();
+  if (!value) {
+    return null;
+  }
+  const separator = value.indexOf(":");
+  if (separator <= 0 || separator >= value.length - 1) {
+    return null;
+  }
+  return {
+    channel: value.slice(0, separator),
+    chatId: value.slice(separator + 1)
+  };
+}
+function enqueuePendingSystemEvent(sessionManager, sessionKey, message) {
+  const text = message.trim();
+  if (!text) {
+    return;
+  }
+  const session = sessionManager.getOrCreate(sessionKey);
+  const queueRaw = session.metadata[PENDING_SYSTEM_EVENTS_KEY];
+  const queue = Array.isArray(queueRaw) ? queueRaw.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean) : [];
+  if (queue.at(-1) === text) {
+    return;
+  }
+  queue.push(text);
+  if (queue.length > 20) {
+    queue.splice(0, queue.length - 20);
+  }
+  session.metadata[PENDING_SYSTEM_EVENTS_KEY] = queue;
+  session.updatedAt = /* @__PURE__ */ new Date();
+  sessionManager.save(session);
+}
+
+// src/cli/gateway/controller.ts
 var hashRaw = (raw) => createHash("sha256").update(raw).digest("hex");
 var readConfigSnapshot = (getConfigPath4) => {
   const path = getConfigPath4();
   let raw = "";
   let parsed = {};
-  if (existsSync5(path)) {
-    raw = readFileSync3(path, "utf-8");
+  if (existsSync6(path)) {
+    raw = readFileSync4(path, "utf-8");
     try {
       parsed = JSON.parse(raw);
     } catch {
@@ -1834,6 +1934,60 @@ var GatewayControllerImpl = class {
   constructor(deps) {
     this.deps = deps;
   }
+  normalizeOptionalString(value) {
+    if (typeof value !== "string") {
+      return void 0;
+    }
+    const trimmed = value.trim();
+    return trimmed || void 0;
+  }
+  resolveDeliveryContext(sessionKey) {
+    const normalizedSessionKey = this.normalizeOptionalString(sessionKey);
+    const keyTarget = parseSessionKey(normalizedSessionKey);
+    const session = normalizedSessionKey ? this.deps.sessionManager?.getIfExists(normalizedSessionKey) : null;
+    const metadata = session?.metadata ?? {};
+    const rawContext = metadata.last_delivery_context;
+    const cachedContext = rawContext && typeof rawContext === "object" && !Array.isArray(rawContext) ? rawContext : null;
+    const cachedMetadataRaw = cachedContext?.metadata;
+    const cachedMetadata = cachedMetadataRaw && typeof cachedMetadataRaw === "object" && !Array.isArray(cachedMetadataRaw) ? { ...cachedMetadataRaw } : {};
+    const channel = this.normalizeOptionalString(cachedContext?.channel) ?? keyTarget?.channel;
+    const chatId = this.normalizeOptionalString(cachedContext?.chatId) ?? this.normalizeOptionalString(metadata.last_to) ?? keyTarget?.chatId;
+    const replyTo = this.normalizeOptionalString(cachedContext?.replyTo) ?? this.normalizeOptionalString(metadata.last_message_id);
+    const accountId = this.normalizeOptionalString(cachedContext?.accountId) ?? this.normalizeOptionalString(metadata.last_account_id);
+    if (!channel || !chatId) {
+      return void 0;
+    }
+    if (accountId && !this.normalizeOptionalString(cachedMetadata.accountId)) {
+      cachedMetadata.accountId = accountId;
+    }
+    return {
+      channel,
+      chatId,
+      ...replyTo ? { replyTo } : {},
+      ...accountId ? { accountId } : {},
+      ...Object.keys(cachedMetadata).length > 0 ? { metadata: cachedMetadata } : {}
+    };
+  }
+  async writeRestartSentinelPayload(params) {
+    const sessionKey = this.normalizeOptionalString(params.sessionKey);
+    const deliveryContext = this.resolveDeliveryContext(sessionKey);
+    try {
+      return await writeRestartSentinel({
+        kind: params.kind,
+        status: params.status,
+        ts: Date.now(),
+        sessionKey,
+        deliveryContext,
+        message: params.note ?? null,
+        stats: {
+          reason: params.reason ?? null,
+          strategy: params.strategy ?? null
+        }
+      });
+    } catch {
+      return null;
+    }
+  }
   async requestRestart(options) {
     if (this.deps.requestRestart) {
       await this.deps.requestRestart(options);
@@ -1899,13 +2053,21 @@ var GatewayControllerImpl = class {
     }
     this.deps.saveConfig(validated);
     const delayMs = params.restartDelayMs ?? 0;
+    const sentinelPath = await this.writeRestartSentinelPayload({
+      kind: "config.apply",
+      status: "ok",
+      sessionKey: params.sessionKey,
+      note: params.note,
+      reason: "config.apply"
+    });
     await this.requestRestart({ delayMs, reason: "config.apply" });
     return {
       ok: true,
       note: params.note ?? null,
       path: this.deps.getConfigPath(),
       config: redactValue(validated),
-      restart: { scheduled: true, delayMs }
+      restart: { scheduled: true, delayMs },
+      sentinel: sentinelPath ? { path: sentinelPath } : null
     };
   }
   async patchConfig(params) {
@@ -1934,13 +2096,21 @@ var GatewayControllerImpl = class {
     }
     this.deps.saveConfig(validated);
     const delayMs = params.restartDelayMs ?? 0;
+    const sentinelPath = await this.writeRestartSentinelPayload({
+      kind: "config.patch",
+      status: "ok",
+      sessionKey: params.sessionKey,
+      note: params.note,
+      reason: "config.patch"
+    });
     await this.requestRestart({ delayMs, reason: "config.patch" });
     return {
       ok: true,
       note: params.note ?? null,
       path: this.deps.getConfigPath(),
       config: redactValue(validated),
-      restart: { scheduled: true, delayMs }
+      restart: { scheduled: true, delayMs },
+      sentinel: sentinelPath ? { path: sentinelPath } : null
     };
   }
   async updateRun(params) {
@@ -1949,13 +2119,22 @@ var GatewayControllerImpl = class {
       return { ok: false, error: result.error ?? "update failed", steps: result.steps };
     }
     const delayMs = params.restartDelayMs ?? 0;
+    const sentinelPath = await this.writeRestartSentinelPayload({
+      kind: "update.run",
+      status: "ok",
+      sessionKey: params.sessionKey,
+      note: params.note,
+      reason: "update.run",
+      strategy: result.strategy
+    });
     await this.requestRestart({ delayMs, reason: "update.run" });
     return {
       ok: true,
       note: params.note ?? null,
       restart: { scheduled: true, delayMs },
       strategy: result.strategy,
-      steps: result.steps
+      steps: result.steps,
+      sentinel: sentinelPath ? { path: sentinelPath } : null
     };
   }
 };
@@ -2126,7 +2305,7 @@ var ServiceCommands = class {
       config: config2
     });
     const sessionManager = new SessionManager(workspace);
-    const cronStorePath = join4(getDataDir4(), "cron", "jobs.json");
+    const cronStorePath = join4(getDataDir5(), "cron", "jobs.json");
     const cron2 = new CronService2(cronStorePath);
     const uiConfig = resolveUiConfig(config2, options.uiOverrides);
     const uiStaticDir = options.uiStaticDir === void 0 ? resolveUiStaticDir() : options.uiStaticDir;
@@ -2154,6 +2333,7 @@ var ServiceCommands = class {
     const gatewayController = new GatewayControllerImpl({
       reloader,
       cron: cron2,
+      sessionManager,
       getConfigPath: getConfigPath2,
       saveConfig: saveConfig4,
       requestRestart: async (options2) => {
@@ -2300,12 +2480,97 @@ var ServiceCommands = class {
           console.warn(`[plugins] ${text}`);
         }
       }
-      await Promise.allSettled([agent.run(), reloader.getChannels().startAll()]);
+      await reloader.getChannels().startAll();
+      await this.wakeFromRestartSentinel({ channels: reloader.getChannels(), sessionManager });
+      await agent.run();
     } finally {
       await stopPluginChannelGateways(pluginGatewayHandles);
       setPluginRuntimeBridge(null);
     }
   }
+  normalizeOptionalString(value) {
+    if (typeof value !== "string") {
+      return void 0;
+    }
+    const trimmed = value.trim();
+    return trimmed || void 0;
+  }
+  async sleep(ms) {
+    await new Promise((resolve10) => setTimeout(resolve10, ms));
+  }
+  async sendRestartSentinelNotice(params) {
+    const outboundBase = {
+      channel: params.channel,
+      chatId: params.chatId,
+      content: params.content,
+      media: [],
+      metadata: params.metadata
+    };
+    const variants = params.replyTo ? [
+      { ...outboundBase, replyTo: params.replyTo },
+      { ...outboundBase }
+    ] : [{ ...outboundBase }];
+    for (let variantIndex = 0; variantIndex < variants.length; variantIndex += 1) {
+      const outbound = variants[variantIndex];
+      const isLastVariant = variantIndex === variants.length - 1;
+      for (let attempt = 1; attempt <= 3; attempt += 1) {
+        try {
+          const delivered = await params.channels.deliver(outbound);
+          if (delivered) {
+            return true;
+          }
+          return false;
+        } catch (error) {
+          if (attempt < 3) {
+            await this.sleep(attempt * 500);
+            continue;
+          }
+          if (isLastVariant) {
+            console.warn(
+              `Warning: restart sentinel notify failed for ${params.channel}:${params.chatId} (attempt ${attempt}): ${String(error)}`
+            );
+          }
+        }
+      }
+    }
+    return false;
+  }
+  async wakeFromRestartSentinel(params) {
+    const sentinel = await consumeRestartSentinel();
+    if (!sentinel) {
+      return;
+    }
+    await new Promise((resolve10) => setTimeout(resolve10, 750));
+    const payload = sentinel.payload;
+    const message = formatRestartSentinelMessage(payload);
+    const sessionKey = this.normalizeOptionalString(payload.sessionKey) ?? "cli:default";
+    const parsedSession = parseSessionKey(sessionKey);
+    const context = payload.deliveryContext;
+    const channel = this.normalizeOptionalString(context?.channel) ?? parsedSession?.channel ?? this.normalizeOptionalString((params.sessionManager.getIfExists(sessionKey)?.metadata ?? {}).last_channel);
+    const chatId = this.normalizeOptionalString(context?.chatId) ?? parsedSession?.chatId ?? this.normalizeOptionalString((params.sessionManager.getIfExists(sessionKey)?.metadata ?? {}).last_to);
+    const replyTo = this.normalizeOptionalString(context?.replyTo);
+    const accountId = this.normalizeOptionalString(context?.accountId);
+    const metadataRaw = context?.metadata;
+    const metadata = metadataRaw && typeof metadataRaw === "object" && !Array.isArray(metadataRaw) ? { ...metadataRaw } : {};
+    if (accountId && !this.normalizeOptionalString(metadata.accountId)) {
+      metadata.accountId = accountId;
+    }
+    if (!channel || !chatId) {
+      enqueuePendingSystemEvent(params.sessionManager, sessionKey, message);
+      return;
+    }
+    const delivered = await this.sendRestartSentinelNotice({
+      channels: params.channels,
+      channel,
+      chatId,
+      content: message,
+      ...replyTo ? { replyTo } : {},
+      metadata
+    });
+    if (!delivered) {
+      enqueuePendingSystemEvent(params.sessionManager, sessionKey, message);
+    }
+  }
   async runForeground(options) {
     const config2 = loadConfig5();
     const uiConfig = resolveUiConfig(config2, options.uiOverrides);
@@ -2369,8 +2634,8 @@ var ServiceCommands = class {
       console.log("Warning: UI frontend not found in package assets.");
     }
     const logPath = resolveServiceLogPath();
-    const logDir = resolve6(logPath, "..");
-    mkdirSync2(logDir, { recursive: true });
+    const logDir = resolve7(logPath, "..");
+    mkdirSync3(logDir, { recursive: true });
     const logFd = openSync(logPath, "a");
     const serveArgs = buildServeArgs({
       uiPort: uiConfig.port
@@ -2464,22 +2729,22 @@ var ServiceCommands = class {
       try {
         const response = await fetch(params.healthUrl, { method: "GET" });
         if (!response.ok) {
-          await new Promise((resolve9) => setTimeout(resolve9, 200));
+          await new Promise((resolve10) => setTimeout(resolve10, 200));
           continue;
         }
         const payload = await response.json();
         const healthy = payload?.ok === true && payload?.data?.status === "ok";
         if (!healthy) {
-          await new Promise((resolve9) => setTimeout(resolve9, 200));
+          await new Promise((resolve10) => setTimeout(resolve10, 200));
           continue;
         }
-        await new Promise((resolve9) => setTimeout(resolve9, 300));
+        await new Promise((resolve10) => setTimeout(resolve10, 300));
         if (isProcessRunning(params.pid)) {
           return true;
         }
       } catch {
       }
-      await new Promise((resolve9) => setTimeout(resolve9, 200));
+      await new Promise((resolve10) => setTimeout(resolve10, 200));
     }
     return false;
   }
@@ -2552,11 +2817,11 @@ var ServiceCommands = class {
 };
 
 // src/cli/workspace.ts
-import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, readdirSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { cpSync, existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync5, readdirSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
 import { createRequire } from "module";
-import { dirname, join as join5, resolve as resolve7 } from "path";
+import { dirname, join as join5, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { APP_NAME as APP_NAME3, getDataDir as getDataDir5 } from "@nextclaw/core";
+import { APP_NAME as APP_NAME3, getDataDir as getDataDir6 } from "@nextclaw/core";
 import { spawnSync as spawnSync4 } from "child_process";
 var WorkspaceManager = class {
   constructor(logo) {
@@ -2585,28 +2850,28 @@ var WorkspaceManager = class {
     ];
     for (const entry of templateFiles) {
       const filePath = join5(workspace, entry.target);
-      if (!force && existsSync6(filePath)) {
+      if (!force && existsSync7(filePath)) {
         continue;
       }
       const templatePath = join5(templateDir, entry.source);
-      if (!existsSync6(templatePath)) {
+      if (!existsSync7(templatePath)) {
         console.warn(`Warning: Template file missing: ${templatePath}`);
         continue;
       }
-      const raw = readFileSync4(templatePath, "utf-8");
+      const raw = readFileSync5(templatePath, "utf-8");
       const content = raw.replace(/\$\{APP_NAME\}/g, APP_NAME3);
-      mkdirSync3(dirname(filePath), { recursive: true });
-      writeFileSync2(filePath, content);
+      mkdirSync4(dirname(filePath), { recursive: true });
+      writeFileSync3(filePath, content);
       created.push(entry.target);
     }
     const memoryDir = join5(workspace, "memory");
-    if (!existsSync6(memoryDir)) {
-      mkdirSync3(memoryDir, { recursive: true });
+    if (!existsSync7(memoryDir)) {
+      mkdirSync4(memoryDir, { recursive: true });
       created.push(join5("memory", ""));
     }
     const skillsDir = join5(workspace, "skills");
-    if (!existsSync6(skillsDir)) {
-      mkdirSync3(skillsDir, { recursive: true });
+    if (!existsSync7(skillsDir)) {
+      mkdirSync4(skillsDir, { recursive: true });
       created.push(join5("skills", ""));
     }
     const seeded = this.seedBuiltinSkills(skillsDir, { force });
@@ -2627,11 +2892,11 @@ var WorkspaceManager = class {
         continue;
       }
       const src = join5(sourceDir, entry.name);
-      if (!existsSync6(join5(src, "SKILL.md"))) {
+      if (!existsSync7(join5(src, "SKILL.md"))) {
         continue;
       }
       const dest = join5(targetDir, entry.name);
-      if (!force && existsSync6(dest)) {
+      if (!force && existsSync7(dest)) {
         continue;
       }
       cpSync(src, dest, { recursive: true, force: true });
@@ -2643,13 +2908,13 @@ var WorkspaceManager = class {
     try {
       const require2 = createRequire(import.meta.url);
       const entry = require2.resolve("@nextclaw/core");
-      const pkgRoot = resolve7(dirname(entry), "..");
+      const pkgRoot = resolve8(dirname(entry), "..");
       const distSkills = join5(pkgRoot, "dist", "skills");
-      if (existsSync6(distSkills)) {
+      if (existsSync7(distSkills)) {
         return distSkills;
       }
       const srcSkills = join5(pkgRoot, "src", "agent", "skills");
-      if (existsSync6(srcSkills)) {
+      if (existsSync7(srcSkills)) {
         return srcSkills;
       }
       return null;
@@ -2662,33 +2927,33 @@ var WorkspaceManager = class {
     if (override) {
       return override;
     }
-    const cliDir = resolve7(fileURLToPath2(new URL(".", import.meta.url)));
-    const pkgRoot = resolve7(cliDir, "..", "..");
+    const cliDir = resolve8(fileURLToPath2(new URL(".", import.meta.url)));
+    const pkgRoot = resolve8(cliDir, "..", "..");
     const candidates = [join5(pkgRoot, "templates")];
     for (const candidate of candidates) {
-      if (existsSync6(candidate)) {
+      if (existsSync7(candidate)) {
         return candidate;
       }
     }
     return null;
   }
   getBridgeDir() {
-    const userBridge = join5(getDataDir5(), "bridge");
-    if (existsSync6(join5(userBridge, "dist", "index.js"))) {
+    const userBridge = join5(getDataDir6(), "bridge");
+    if (existsSync7(join5(userBridge, "dist", "index.js"))) {
       return userBridge;
     }
     if (!which("npm")) {
       console.error("npm not found. Please install Node.js >= 18.");
       process.exit(1);
     }
-    const cliDir = resolve7(fileURLToPath2(new URL(".", import.meta.url)));
-    const pkgRoot = resolve7(cliDir, "..", "..");
+    const cliDir = resolve8(fileURLToPath2(new URL(".", import.meta.url)));
+    const pkgRoot = resolve8(cliDir, "..", "..");
     const pkgBridge = join5(pkgRoot, "bridge");
     const srcBridge = join5(pkgRoot, "..", "..", "bridge");
     let source = null;
-    if (existsSync6(join5(pkgBridge, "package.json"))) {
+    if (existsSync7(join5(pkgBridge, "package.json"))) {
       source = pkgBridge;
-    } else if (existsSync6(join5(srcBridge, "package.json"))) {
+    } else if (existsSync7(join5(srcBridge, "package.json"))) {
       source = srcBridge;
     }
     if (!source) {
@@ -2696,9 +2961,9 @@ var WorkspaceManager = class {
       process.exit(1);
     }
     console.log(`${this.logo} Setting up bridge...`);
-    mkdirSync3(resolve7(userBridge, ".."), { recursive: true });
-    if (existsSync6(userBridge)) {
-      rmSync2(userBridge, { recursive: true, force: true });
+    mkdirSync4(resolve8(userBridge, ".."), { recursive: true });
+    if (existsSync7(userBridge)) {
+      rmSync3(userBridge, { recursive: true, force: true });
     }
     cpSync(source, userBridge, {
       recursive: true,
@@ -2822,7 +3087,7 @@ var CliRuntime = class {
     const delayMs = typeof params.delayMs === "number" && Number.isFinite(params.delayMs) ? Math.max(0, Math.floor(params.delayMs)) : 100;
     const cliPath = process.env.NEXTCLAW_SELF_RELAUNCH_CLI?.trim() || fileURLToPath3(new URL("./index.js", import.meta.url));
     const startArgs = [cliPath, "start", "--ui-port", String(uiPort)];
-    const serviceStatePath = resolve8(getDataDir6(), "run", "service.json");
+    const serviceStatePath = resolve9(getDataDir7(), "run", "service.json");
     const helperScript = [
       'const { spawnSync } = require("node:child_process");',
       'const { readFileSync } = require("node:fs");',
@@ -2927,16 +3192,16 @@ var CliRuntime = class {
     const force = Boolean(options.force);
     const configPath = getConfigPath3();
     let createdConfig = false;
-    if (!existsSync7(configPath)) {
+    if (!existsSync8(configPath)) {
       const config3 = ConfigSchema2.parse({});
       saveConfig5(config3);
       createdConfig = true;
     }
     const config2 = loadConfig6();
     const workspaceSetting = config2.agents.defaults.workspace;
-    const workspacePath = !workspaceSetting || workspaceSetting === DEFAULT_WORKSPACE_PATH ? join6(getDataDir6(), DEFAULT_WORKSPACE_DIR) : expandHome2(workspaceSetting);
-    const workspaceExisted = existsSync7(workspacePath);
-    mkdirSync4(workspacePath, { recursive: true });
+    const workspacePath = !workspaceSetting || workspaceSetting === DEFAULT_WORKSPACE_PATH ? join6(getDataDir7(), DEFAULT_WORKSPACE_DIR) : expandHome2(workspaceSetting);
+    const workspaceExisted = existsSync8(workspacePath);
+    mkdirSync5(workspacePath, { recursive: true });
     const templateResult = this.workspaceManager.createWorkspaceTemplates(workspacePath, { force });
     if (createdConfig) {
       console.log(`\u2713 ${prefix}: created config at ${configPath}`);
@@ -3077,14 +3342,14 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
     }
     console.log(`${this.logo} Interactive mode (type exit or Ctrl+C to quit)
 `);
-    const historyFile = join6(getDataDir6(), "history", "cli_history");
-    const historyDir = resolve8(historyFile, "..");
-    mkdirSync4(historyDir, { recursive: true });
-    const history = existsSync7(historyFile) ? readFileSync5(historyFile, "utf-8").split("\n").filter(Boolean) : [];
+    const historyFile = join6(getDataDir7(), "history", "cli_history");
+    const historyDir = resolve9(historyFile, "..");
+    mkdirSync5(historyDir, { recursive: true });
+    const history = existsSync8(historyFile) ? readFileSync6(historyFile, "utf-8").split("\n").filter(Boolean) : [];
     const rl = createInterface2({ input: process.stdin, output: process.stdout });
     rl.on("close", () => {
       const merged = history.concat(rl.history ?? []);
-      writeFileSync3(historyFile, merged.join("\n"));
+      writeFileSync4(historyFile, merged.join("\n"));
       process.exit(0);
     });
     let running = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nextclaw",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "description": "Lightweight personal AI assistant with CLI, multi-provider routing, and channel integrations.",
   "private": false,
   "type": "module",
@@ -38,7 +38,7 @@
   "dependencies": {
     "chokidar": "^3.6.0",
     "commander": "^12.1.0",
-    "@nextclaw/core": "^0.6.7",
+    "@nextclaw/core": "^0.6.9",
     "@nextclaw/server": "^0.4.2",
     "@nextclaw/openclaw-compat": "^0.1.5"
   },

package/templates/USAGE.md

@@ -265,6 +265,7 @@ Behavior:
 - Otherwise it falls back to `npm i -g nextclaw`.
 - If the background service is running, restart it after the update to apply changes.
 - When update is triggered from the running gateway (agent `update.run`), NextClaw arms a self-relaunch helper before exiting, so the service comes back automatically (like an OS reboot flow).
+- After restart, NextClaw automatically pings the last active session with restart/update status (including note when provided).
 
 If the gateway is running, you can also ask the agent to update; the agent will call the gateway update tool only when you explicitly request it, and restart/relaunch will be scheduled afterward.