lody 0.89.4 → 0.90.0

package/dist/chunks/{profile-Cxxl5hCq.js → profile-CPDWaQXE.js}

@@ -63,7 +63,7 @@ const DEEPSEEK_HARNESS_AGENT_PRESETS = [
   }
 ];
 const ACP_EXTENSION_DSH_VERSION = "0.1.0";
-const DEEPSEEK_HARNESS_VERSION = "0.1.1-rc.1";
+const DEEPSEEK_HARNESS_VERSION = "0.1.1-rc.2";
 const ACP_EXTENSION_DSH_PROFILE_REVISION = "v5";
 const ACP_EXTENSION_DSH_SESSION_ROOT_ENV = "ACP_EXTENSION_DSH_SESSION_ROOT";
 const ACP_EXTENSION_DSH_QUERY_PATH_ENV = "ACP_EXTENSION_DSH_QUERY_PATH";

package/dist/chunks/{review-viewer-HMN3RPEa.js → review-viewer-CGdWKpLa.js}

@@ -32,7 +32,7 @@ import "perf_hooks";
 import "net";
 import "tls";
 import "url";
-import "./profile-Cxxl5hCq.js";
+import "./profile-CPDWaQXE.js";
 import "assert";
 import "fs/promises";
 import "better-sqlite3";
@@ -80,7 +80,7 @@ let __tla = Promise.all([
     }
   })()
 ]).then(async () => {
-  const reviewViewerVersion = "0.89.4";
+  const reviewViewerVersion = "0.90.0";
   const reviewViewerSha256 = "dc9c7fc1dde49bb39c5fe86392d69219b469c0cab4fd492d8b562045e7f676e4";
   const reviewViewerFileName = "standalone.html";
   const DEFAULT_CDN_BASES = [

package/dist/deepseek-acp.js

@@ -2,7 +2,7 @@ import { randomUUID, createHash } from "node:crypto";
 import { isAbsolute } from "node:path";
 import { Readable, Writable } from "node:stream";
 import { n as ndJsonStream, A as AgentSideConnection, R as RequestError, P as PROTOCOL_VERSION } from "./chunks/acp-DBqkNziA.js";
-import { D as DEEPSEEK_HARNESS_PERMISSION_MODES, c as DEEPSEEK_HARNESS_REASONING_OPTIONS, e as ACP_EXTENSION_DSH_VERSION, a as DEEPSEEK_HARNESS_AGENT_PRESETS } from "./chunks/profile-Cxxl5hCq.js";
+import { D as DEEPSEEK_HARNESS_PERMISSION_MODES, c as DEEPSEEK_HARNESS_REASONING_OPTIONS, e as ACP_EXTENSION_DSH_VERSION, a as DEEPSEEK_HARNESS_AGENT_PRESETS } from "./chunks/profile-CPDWaQXE.js";
 import "./chunks/schemas-Du3qLZPS.js";
 const name = "acp-extension-dsh";
 const inject = [

package/dist/index.js

@@ -14,7 +14,7 @@ import * as os$1 from "node:os";
 import os__default, { userInfo, homedir, cpus } from "node:os";
 import * as path from "node:path";
 import path__default, { posix as posix$1, basename, win32, join as join$2, resolve as resolve$1, dirname as dirname$1, relative as relative$1, isAbsolute as isAbsolute$2, sep as sep$1, delimiter, normalize } from "node:path";
-import { _ as _coercedNumber, Z as ZodNumber$1, o as object$1, s as string$1, l as literal$1, n as number$4, b as boolean, a as _enum$1, c as array$2, d as discriminatedUnion, e as _instanceof, r as record$1, u as unknown, f as union$7, p as preprocess, g as ZodError$1, h as _null, i as normalizeParams, $ as $constructor, j as $ZodObject, k as defineLazy, m as $ZodType, q as parse$5, t as safeParse$1, v as parseAsync, w as safeParseAsync$1, x as clone$2, y as looseObject, z as intersection, A as optional$1, B as datetime, C as custom$1, D as toJSONSchema, E as ZodOptional$1, F as never$1, G as xor } from "./chunks/schemas-Du3qLZPS.js";
+import { _ as _coercedNumber, Z as ZodNumber$1, o as object$1, s as string$1, l as literal$1, n as number$4, b as boolean, a as _enum$1, c as array$2, r as record$1, d as discriminatedUnion, e as _instanceof, u as unknown, f as union$7, p as preprocess, g as ZodError$1, h as _null, i as normalizeParams, $ as $constructor, j as $ZodObject, k as defineLazy, m as $ZodType, q as parse$5, t as safeParse$1, v as parseAsync, w as safeParseAsync$1, x as clone$2, y as looseObject, z as intersection, A as optional$1, B as datetime, C as custom$1, D as toJSONSchema, E as ZodOptional$1, F as never$1, G as xor } from "./chunks/schemas-Du3qLZPS.js";
 import require$$0$4, { once as once$1, EventEmitter as EventEmitter$1 } from "node:events";
 import Tw__default, { execFile, spawn as spawn$1, execFileSync } from "node:child_process";
 import process$2 from "node:process";
@@ -42,7 +42,7 @@ import { performance as performance$1 } from "perf_hooks";
 import require$$0$9 from "net";
 import require$$4$2 from "tls";
 import require$$7$2, { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1 } from "url";
-import { D as DEEPSEEK_HARNESS_PERMISSION_MODES, a as DEEPSEEK_HARNESS_AGENT_PRESETS, b as DEEPSEEK_HARNESS_MODELS, c as DEEPSEEK_HARNESS_REASONING_OPTIONS, A as ACP_EXTENSION_DSH_CAPABILITY_SOURCE_VERSION, d as createDeepSeekHarnessCordisConfig, e as ACP_EXTENSION_DSH_VERSION, f as ACP_EXTENSION_DSH_PROFILE_REVISION, g as ACP_EXTENSION_DSH_QUERY_PATH_ENV, h as ACP_EXTENSION_DSH_SESSION_ROOT_ENV, i as DEEPSEEK_HARNESS_NPX_PACKAGES, j as DEEPSEEK_HARNESS_VERSION, k as DEEPSEEK_HARNESS_DEFAULT_SESSION_COMPRESSION } from "./chunks/profile-Cxxl5hCq.js";
+import { D as DEEPSEEK_HARNESS_PERMISSION_MODES, a as DEEPSEEK_HARNESS_AGENT_PRESETS, b as DEEPSEEK_HARNESS_MODELS, c as DEEPSEEK_HARNESS_REASONING_OPTIONS, A as ACP_EXTENSION_DSH_CAPABILITY_SOURCE_VERSION, d as createDeepSeekHarnessCordisConfig, e as ACP_EXTENSION_DSH_VERSION, f as ACP_EXTENSION_DSH_PROFILE_REVISION, g as ACP_EXTENSION_DSH_QUERY_PATH_ENV, h as ACP_EXTENSION_DSH_SESSION_ROOT_ENV, i as DEEPSEEK_HARNESS_NPX_PACKAGES, j as DEEPSEEK_HARNESS_VERSION, k as DEEPSEEK_HARNESS_DEFAULT_SESSION_COMPRESSION } from "./chunks/profile-CPDWaQXE.js";
 import assert from "assert";
 import * as fs$2 from "fs/promises";
 import fs__default$2 from "fs/promises";
@@ -4325,7 +4325,7 @@ Upgrade Node, then re-run: npx lody@latest`;
   }
   const name$2 = "lody";
   const name$1 = "@lody/cli-cloud";
-  const version$9 = "0.89.4";
+  const version$9 = "0.90.0";
   const type$2 = "module";
   const scripts = {
     "dev": "node dev.mjs",
@@ -11506,6 +11506,10 @@ Requirements:
       connection: CliBackendConnectionSchema
     }).strict().optional(),
     connectedWorkspaces: array$2(CliRuntimeWorkspaceSchema).optional(),
+    connectionAges: object$1({
+      backendNotConnectedSinceMs: number$4().int().nonnegative().optional(),
+      workspaceNotConnectedSinceMs: record$1(string$1().min(1), number$4().int().nonnegative()).optional()
+    }).strict().optional(),
     machineId: string$1().min(1).optional(),
     pid: number$4().int(),
     updatedAtMs: number$4(),
@@ -23342,28 +23346,35 @@ ${context2.authorReply.trim()}
       ...right2
     ];
   };
-  const classifyIpv4 = ([first2, second, third, fourth]) => {
+  const isBenchmarkingIpv4 = ([first2, second]) => first2 === 198 && (second === 18 || second === 19);
+  const classifyIpv4 = (octets) => {
+    const [first2, second, third, fourth] = octets;
     if (first2 === 127) return "loopback";
     if (first2 === 10 || first2 === 172 && second >= 16 && second <= 31) return "private-lan";
     if (first2 === 192 && second === 168) return "private-lan";
-    const prohibited = first2 === 0 || first2 >= 224 || first2 === 100 && second >= 64 && second <= 127 || first2 === 169 && second === 254 || first2 === 192 && second === 0 && third === 0 || first2 === 192 && second === 0 && third === 2 || first2 === 198 && (second === 18 || second === 19) || first2 === 198 && second === 51 && third === 100 || first2 === 203 && second === 0 && third === 113 || first2 === 255 && second === 255 && third === 255 && fourth === 255;
+    const prohibited = first2 === 0 || first2 >= 224 || first2 === 100 && second >= 64 && second <= 127 || first2 === 169 && second === 254 || first2 === 192 && second === 0 && third === 0 || first2 === 192 && second === 0 && third === 2 || isBenchmarkingIpv4(octets) || first2 === 198 && second === 51 && third === 100 || first2 === 203 && second === 0 && third === 113 || first2 === 255 && second === 255 && third === 255 && fourth === 255;
     return prohibited ? "prohibited" : "public";
   };
+  const mappedIpv4 = (segments) => {
+    if (!segments.slice(0, 5).every((segment) => segment === 0) || segments[5] !== 65535) {
+      return null;
+    }
+    const high = segments[6] ?? 0;
+    const low = segments[7] ?? 0;
+    return [
+      high >> 8,
+      high & 255,
+      low >> 8,
+      low & 255
+    ];
+  };
   const classifyIpv6 = (segments) => {
     if (segments.every((segment) => segment === 0)) return "prohibited";
     if (segments.slice(0, 7).every((segment) => segment === 0) && segments[7] === 1) {
       return "loopback";
     }
-    if (segments.slice(0, 5).every((segment) => segment === 0) && segments[5] === 65535) {
-      const high = segments[6] ?? 0;
-      const low = segments[7] ?? 0;
-      return classifyIpv4([
-        high >> 8,
-        high & 255,
-        low >> 8,
-        low & 255
-      ]);
-    }
+    const mapped = mappedIpv4(segments);
+    if (mapped) return classifyIpv4(mapped);
     const first2 = segments[0] ?? 0;
     if ((first2 & 65024) === 64512) return "private-lan";
     if ((first2 & 65472) === 65152 || (first2 & 65280) === 65280) return "prohibited";
@@ -127598,7 +127609,6 @@ ${error2.message}` : execaMessage;
     return {
       command: "npx",
       args: [
-        "--force",
         "--prefer-offline",
         "-y",
         ...DEEPSEEK_HARNESS_NPX_PACKAGES.flatMap((packageName) => [
@@ -129075,7 +129085,7 @@ ${fallbackStderrTail}` : errorMessage2;
       sessionResponse
     };
   };
-  function waitForChildProcessExit$1(child, timeoutMs) {
+  function waitForChildProcessExit$2(child, timeoutMs) {
     if (child.exitCode !== null) {
       return Promise.resolve(true);
     }
@@ -129112,7 +129122,7 @@ ${fallbackStderrTail}` : errorMessage2;
     } catch {
       return;
     }
-    if (await waitForChildProcessExit$1(child, exitTimeoutMs)) {
+    if (await waitForChildProcessExit$2(child, exitTimeoutMs)) {
       return;
     }
     logger2.debug(`[${sessionLabel}] ACP agent process did not exit within ${exitTimeoutMs}ms of SIGTERM; escalating to SIGKILL`);
@@ -129121,7 +129131,7 @@ ${fallbackStderrTail}` : errorMessage2;
     } catch {
       return;
     }
-    await waitForChildProcessExit$1(child, exitTimeoutMs);
+    await waitForChildProcessExit$2(child, exitTimeoutMs);
   }
   const spawnAcpProcess = (options) => {
     let command2 = options.command;
@@ -166472,7 +166482,7 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
   const ACP_OPERATION_TIMEOUT_MS = 12e4;
   const ACP_PROCESS_EXIT_TIMEOUT_MS = 3e3;
   const MAX_LOCAL_PROJECT_HISTORY_CATALOG_SESSIONS = 100;
-  function waitForChildProcessExit(child, timeoutMs) {
+  function waitForChildProcessExit$1(child, timeoutMs) {
     if (child.exitCode !== null) {
       return Promise.resolve(true);
     }
@@ -166504,7 +166514,7 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
     } catch {
       return;
     }
-    if (await waitForChildProcessExit(child, ACP_PROCESS_EXIT_TIMEOUT_MS)) {
+    if (await waitForChildProcessExit$1(child, ACP_PROCESS_EXIT_TIMEOUT_MS)) {
       return;
     }
     try {
@@ -166512,7 +166522,7 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
     } catch {
       return;
     }
-    await waitForChildProcessExit(child, ACP_PROCESS_EXIT_TIMEOUT_MS);
+    await waitForChildProcessExit$1(child, ACP_PROCESS_EXIT_TIMEOUT_MS);
   }
   async function withTimeout(promise2, label2) {
     let timeout2 = null;
@@ -193456,20 +193466,29 @@ ${trimmed2}${closing}`;
     phase = "starting";
     startupStage = "bootstrap";
     connectivity;
-    backend = {
-      authorization: "pending",
-      connection: "connecting"
-    };
+    backend;
+    backendNotConnectedSinceMs;
     connectedWorkspaces = [];
+    workspaceNotConnectedSinceMs = /* @__PURE__ */ new Map();
     machineId;
     activeSessionCount = 0;
     connectedRoomCount = 0;
-    updatedAtMs = Date.now();
+    updatedAtMs;
     issuesByCode = /* @__PURE__ */ new Map();
+    trackBackendConnectionAge;
+    now;
     constructor(options = {}) {
       this.pid = options.pid ?? process.pid;
       this.machineId = options.machineId;
       this.supervisor = options.supervisor;
+      this.trackBackendConnectionAge = options.trackBackendConnectionAge ?? true;
+      this.now = options.now ?? Date.now;
+      this.updatedAtMs = this.now();
+      this.backend = {
+        authorization: "pending",
+        connection: "connecting"
+      };
+      this.backendNotConnectedSinceMs = this.trackBackendConnectionAge ? this.updatedAtMs : void 0;
     }
     setMachineId(machineId) {
       if (this.machineId === machineId) {
@@ -193517,24 +193536,52 @@ ${trimmed2}${closing}`;
       this.touch();
     }
     setBackendConnection(connection2) {
-      if (this.backend.connection === connection2) {
+      const nowMs2 = this.now();
+      const notConnectedSinceMs = !this.trackBackendConnectionAge || connection2 === "connected" ? void 0 : this.backend.connection === "connected" ? nowMs2 : this.backendNotConnectedSinceMs ?? nowMs2;
+      if (this.backend.connection === connection2 && this.backendNotConnectedSinceMs === notConnectedSinceMs) {
         return;
       }
       this.backend = {
         ...this.backend,
         connection: connection2
       };
+      this.backendNotConnectedSinceMs = notConnectedSinceMs;
       this.touch();
     }
     setConnectedWorkspaces(workspaces) {
-      if (JSON.stringify(this.connectedWorkspaces) === JSON.stringify(workspaces)) {
+      const nowMs2 = this.now();
+      const previousById = new Map(this.connectedWorkspaces.map((workspace) => [
+        workspace.id,
+        workspace
+      ]));
+      const nextWorkspaceNotConnectedSinceMs = /* @__PURE__ */ new Map();
+      const nextWorkspaces = workspaces.map((workspace) => {
+        const previous = previousById.get(workspace.id);
+        const notConnectedSinceMs = !this.trackBackendConnectionAge || workspace.backendConnection === "connected" ? void 0 : previous?.backendConnection === "connected" ? nowMs2 : this.workspaceNotConnectedSinceMs.get(workspace.id) ?? nowMs2;
+        if (notConnectedSinceMs !== void 0) {
+          nextWorkspaceNotConnectedSinceMs.set(workspace.id, notConnectedSinceMs);
+        }
+        return {
+          id: workspace.id,
+          name: workspace.name,
+          slug: workspace.slug,
+          role: workspace.role,
+          backendConnection: workspace.backendConnection
+        };
+      });
+      if (JSON.stringify(this.connectedWorkspaces) === JSON.stringify(nextWorkspaces) && JSON.stringify([
+        ...this.workspaceNotConnectedSinceMs
+      ]) === JSON.stringify([
+        ...nextWorkspaceNotConnectedSinceMs
+      ])) {
         return;
       }
-      this.connectedWorkspaces = workspaces;
+      this.connectedWorkspaces = nextWorkspaces;
+      this.workspaceNotConnectedSinceMs = nextWorkspaceNotConnectedSinceMs;
       this.touch();
     }
     upsertIssue(input2) {
-      const nowMs2 = Date.now();
+      const nowMs2 = this.now();
       const existing = this.issuesByCode.get(input2.code);
       if (existing) {
         const next2 = {
@@ -193599,6 +193646,14 @@ ${trimmed2}${closing}`;
         connectivity: this.connectivity,
         backend: this.backend,
         connectedWorkspaces: this.connectedWorkspaces,
+        connectionAges: this.trackBackendConnectionAge ? {
+          ...this.backendNotConnectedSinceMs === void 0 ? {} : {
+            backendNotConnectedSinceMs: this.backendNotConnectedSinceMs
+          },
+          ...this.workspaceNotConnectedSinceMs.size === 0 ? {} : {
+            workspaceNotConnectedSinceMs: Object.fromEntries(this.workspaceNotConnectedSinceMs)
+          }
+        } : void 0,
         machineId: this.machineId,
         pid: this.pid,
         updatedAtMs: this.updatedAtMs,
@@ -193625,7 +193680,7 @@ ${trimmed2}${closing}`;
       }
     }
     touch() {
-      this.updatedAtMs = Date.now();
+      this.updatedAtMs = this.now();
       this.phase = this.computePhase();
     }
     computePhase() {
@@ -194171,7 +194226,7 @@ Shutting down gracefully${reason}...`);
           }
           if (!hostRecord) {
             hostRecord = parseRecord(value);
-            if (!hostRecord || hostRecord.instanceId !== options.instanceId || options.expectedPid !== void 0 && hostRecord.pid !== options.expectedPid || hostRecord.mode !== options.expectedMode) {
+            if (!hostRecord || hostRecord.instanceId !== options.instanceId || options.expectedPid !== void 0 && hostRecord.pid !== options.expectedPid || options.expectedMode !== void 0 && hostRecord.mode !== options.expectedMode) {
               finish({
                 ok: false,
                 error: "owner_mismatch"
@@ -194337,7 +194392,8 @@ Shutting down gracefully${reason}...`);
     };
     const authFailureExitCode = supervisorIdentity ? EXIT_CODE_AUTH_FAILURE : 1;
     const runtimeStateReporter = new CliRuntimeStateReporter({
-      supervisor: toRuntimeSupervisorIdentity(supervisorIdentity)
+      supervisor: toRuntimeSupervisorIdentity(supervisorIdentity),
+      trackBackendConnectionAge: platformKind === "cloud"
     });
     runtimeStateReporter.setStartupStage("bootstrap");
     const electronManaged = supervisorIdentity?.launchMode === "electron";
@@ -222170,7 +222226,7 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
       data = createReviewBundleSnapshot(bundle);
     }
     const { injectReviewSnapshot } = await import("./chunks/index-VoI6Ds2-.js");
-    const { resolveReviewViewerTemplate } = await import("./chunks/review-viewer-HMN3RPEa.js").then(async (m) => {
+    const { resolveReviewViewerTemplate } = await import("./chunks/review-viewer-CGdWKpLa.js").then(async (m) => {
       await m.__tla;
       return m;
     });
@@ -222340,7 +222396,7 @@ ${result.stderr}`;
   const DEFAULT_HEALTHY_RUN_MS = 6e4;
   const DEFAULT_TERMINATION_GRACE_MS = 3e4;
   const DEFAULT_FORCE_KILL_WAIT_MS = 5e3;
-  function isChildProcessRunning(child) {
+  function isChildProcessRunning$1(child) {
     return child !== null && child.exitCode === null && child.signalCode === null;
   }
   function runtimeMatchesHost(runtime, host) {
@@ -222760,7 +222816,7 @@ ${result.stderr}`;
     startHealthyRunTimer(run2) {
       this.clearHealthyRunTimer();
       const timer2 = setTimeout(() => {
-        if (this.healthyRunTimer !== timer2 || this.activeRun !== run2 || !this.isCurrent(run2.generation) || !isChildProcessRunning(run2.handle.child)) {
+        if (this.healthyRunTimer !== timer2 || this.activeRun !== run2 || !this.isCurrent(run2.generation) || !isChildProcessRunning$1(run2.handle.child)) {
           return;
         }
         this.healthyRunTimer = null;
@@ -222810,7 +222866,7 @@ ${result.stderr}`;
       this.signalChild(run2.handle.child, "SIGTERM");
     }
     signalChild(child, signal) {
-      if (!isChildProcessRunning(child)) return;
+      if (!isChildProcessRunning$1(child)) return;
       try {
         child.kill(signal);
       } catch {
@@ -222831,7 +222887,7 @@ ${result.stderr}`;
       }
     }
     async waitForChildExit(child) {
-      if (!isChildProcessRunning(child)) return;
+      if (!isChildProcessRunning$1(child)) return;
       await new Promise((resolve2) => {
         let settled = false;
         const finish = () => {
@@ -222843,7 +222899,7 @@ ${result.stderr}`;
         };
         child.once("exit", finish);
         child.once("close", finish);
-        if (!isChildProcessRunning(child)) finish();
+        if (!isChildProcessRunning$1(child)) finish();
       });
     }
     async abortable(operation, signal, message) {
@@ -223033,7 +223089,7 @@ ${result.stderr}`;
     }
     buildState() {
       const runtime = this.latestRuntimeState;
-      const childRunning = isChildProcessRunning(this.activeRun?.handle.child ?? null);
+      const childRunning = isChildProcessRunning$1(this.activeRun?.handle.child ?? null);
       let phase;
       if (this.desiredState === "stopped") {
         phase = childRunning ? "stopping" : runtime ? phaseFromRuntime(runtime) : "stopped";
@@ -223197,6 +223253,8 @@ ${result.stdout ?? ""}`;
   const DAEMON_RUNNER_READY_FD = 3;
   const DAEMON_RUNNER_READY_TIMEOUT_MS = 3e4;
   const DAEMON_RUNNER_READY_MAX_BUFFER = 8 * 1024;
+  const DAEMON_RUNNER_SHUTDOWN_GRACE_MS = 4e4;
+  const DAEMON_RUNNER_FORCE_KILL_WAIT_MS = 5e3;
   const DaemonRunnerLaunchOutcomeSchema = discriminatedUnion("status", [
     object$1({
       status: literal$1("ready"),
@@ -223229,6 +223287,94 @@ ${result.stdout ?? ""}`;
     } catch {
     }
   }
+  function interpretDaemonRunnerLaunchOutcome(outcome, runnerPid) {
+    switch (outcome.status) {
+      case "ready":
+        return {
+          outcome: {
+            status: "ready",
+            pid: runnerPid,
+            instanceId: outcome.instanceId
+          },
+          cancelRunner: false
+        };
+      case "occupied":
+        return {
+          outcome: {
+            status: "occupied",
+            runnerPid,
+            ownerMode: outcome.ownerMode,
+            ownerPid: outcome.ownerPid
+          },
+          cancelRunner: false
+        };
+      case "error":
+        return {
+          outcome: {
+            status: "error",
+            runnerPid,
+            message: outcome.message
+          },
+          cancelRunner: true
+        };
+      default: {
+        const unreachable = outcome;
+        return unreachable;
+      }
+    }
+  }
+  function isChildProcessRunning(child) {
+    return child.exitCode === null && child.signalCode === null;
+  }
+  async function waitForChildProcessExit(child, timeoutMs) {
+    if (!isChildProcessRunning(child)) return true;
+    return await new Promise((resolve2) => {
+      let settled = false;
+      let timeout2;
+      let onExit2;
+      const finish = (exited) => {
+        if (settled) return;
+        settled = true;
+        if (timeout2 !== void 0) clearTimeout(timeout2);
+        child.off("exit", onExit2);
+        child.off("close", onExit2);
+        resolve2(exited);
+      };
+      onExit2 = () => finish(true);
+      timeout2 = setTimeout(() => finish(!isChildProcessRunning(child)), timeoutMs);
+      child.once("exit", onExit2);
+      child.once("close", onExit2);
+      if (!isChildProcessRunning(child)) finish(true);
+    });
+  }
+  async function terminateSpawnedDaemonRunner(child, runnerPid, options = {}) {
+    if (!isChildProcessRunning(child)) return true;
+    const pidRecord = readPidFileRecord();
+    let gracefulShutdownRequested = false;
+    if (pidRecord?.pid === runnerPid) {
+      const requested = await requestLocalCliHostShutdown({
+        instanceId: pidRecord.instanceId,
+        token: pidRecord.controlToken,
+        expectedPid: runnerPid,
+        expectedMode: "daemon"
+      });
+      gracefulShutdownRequested = requested.ok;
+    }
+    if (!gracefulShutdownRequested) {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }
+    if (await waitForChildProcessExit(child, options.shutdownGraceMs ?? DAEMON_RUNNER_SHUTDOWN_GRACE_MS)) {
+      return true;
+    }
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+    return await waitForChildProcessExit(child, options.forceKillWaitMs ?? DAEMON_RUNNER_FORCE_KILL_WAIT_MS);
+  }
   async function spawnDaemonRunnerAndAwaitReady(passthroughArgs, options = {}) {
     const bin = resolveLodyBin();
     const env2 = {
@@ -223266,26 +223412,30 @@ ${result.stdout ?? ""}`;
       };
     }
     const readyPipe = child.stdio[DAEMON_RUNNER_READY_FD] ?? null;
-    const result = await new Promise((resolve2) => {
+    const waitResult = await new Promise((resolve2) => {
       let settled = false;
       let buffer2 = "";
-      const finish = (outcome) => {
+      let timeout2;
+      const finish = (outcome, cancelRunner = false) => {
         if (settled) return;
         settled = true;
-        clearTimeout(timeout2);
-        resolve2(outcome);
+        if (timeout2 !== void 0) clearTimeout(timeout2);
+        resolve2({
+          outcome,
+          cancelRunner
+        });
       };
-      const timeout2 = setTimeout(() => finish({
+      timeout2 = setTimeout(() => finish({
         status: "timeout",
         runnerPid
-      }), options.timeoutMs ?? DAEMON_RUNNER_READY_TIMEOUT_MS);
+      }, true), options.timeoutMs ?? DAEMON_RUNNER_READY_TIMEOUT_MS);
       timeout2.unref?.();
       if (!readyPipe) {
         finish({
           status: "error",
           runnerPid,
           message: "readiness channel unavailable"
-        });
+        }, true);
         return;
       }
       readyPipe.on("data", (chunk) => {
@@ -223297,7 +223447,7 @@ ${result.stdout ?? ""}`;
               status: "error",
               runnerPid,
               message: "invalid readiness report"
-            });
+            }, true);
           }
           return;
         }
@@ -223309,7 +223459,7 @@ ${result.stdout ?? ""}`;
             status: "error",
             runnerPid,
             message: "invalid readiness report"
-          });
+          }, true);
           return;
         }
         const outcome = DaemonRunnerLaunchOutcomeSchema.safeParse(parsed);
@@ -223318,41 +223468,31 @@ ${result.stdout ?? ""}`;
             status: "error",
             runnerPid,
             message: "invalid readiness report"
-          });
+          }, true);
           return;
         }
-        if (outcome.data.status === "ready") {
-          finish({
-            status: "ready",
-            pid: runnerPid,
-            instanceId: outcome.data.instanceId
-          });
-        } else if (outcome.data.status === "occupied") {
-          finish({
-            status: "occupied",
-            runnerPid,
-            ownerMode: outcome.data.ownerMode,
-            ownerPid: outcome.data.ownerPid
-          });
-        } else {
-          finish({
-            status: "error",
-            runnerPid,
-            message: outcome.data.message
-          });
-        }
+        const interpreted = interpretDaemonRunnerLaunchOutcome(outcome.data, runnerPid);
+        finish(interpreted.outcome, interpreted.cancelRunner);
       });
       readyPipe.once("end", () => finish({
         status: "runner_exited",
         runnerPid
-      }));
+      }, true));
       readyPipe.once("error", () => finish({
         status: "runner_exited",
         runnerPid
-      }));
+      }, true));
     });
     readyPipe?.removeAllListeners();
     readyPipe?.destroy();
+    let result = waitResult.outcome;
+    if (waitResult.cancelRunner && !await terminateSpawnedDaemonRunner(child, runnerPid)) {
+      result = {
+        status: "error",
+        runnerPid,
+        message: `Daemon launch failed (${result.status}) and runner ${runnerPid} did not exit`
+      };
+    }
     child.unref();
     return result;
   }
@@ -223457,21 +223597,115 @@ ${result.stdout ?? ""}`;
       ...sanitized
     ];
   }
-  function formatDaemonBackendStatus(runtimeState) {
+  const DAEMON_CONNECTION_ERROR_AFTER_MS = 6e4;
+  const defaultPalette = {
+    success: chalk.green,
+    warning: chalk.yellow,
+    error: chalk.red,
+    muted: chalk.gray
+  };
+  function formatElapsed(elapsedMs) {
+    const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1e3));
+    if (totalSeconds < 60) return `${totalSeconds}s`;
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    const seconds2 = totalSeconds % 60;
+    if (totalMinutes < 60) {
+      return seconds2 === 0 ? `${totalMinutes}m` : `${totalMinutes}m ${seconds2}s`;
+    }
+    const totalHours = Math.floor(totalMinutes / 60);
+    const minutes2 = totalMinutes % 60;
+    if (totalHours < 24) {
+      return minutes2 === 0 ? `${totalHours}h` : `${totalHours}h ${minutes2}m`;
+    }
+    const days2 = Math.floor(totalHours / 24);
+    const hours2 = totalHours % 24;
+    return hours2 === 0 ? `${days2}d` : `${days2}d ${hours2}h`;
+  }
+  function formatAuthorization(authorization, palette) {
+    switch (authorization) {
+      case "authorized":
+        return palette.success(authorization);
+      case "pending":
+        return palette.warning(authorization);
+      case "rejected":
+        return palette.error(authorization);
+      case "unknown":
+        return palette.muted(authorization);
+      default: {
+        const unreachable = authorization;
+        return unreachable;
+      }
+    }
+  }
+  function formatConnection(connection2, notConnectedSinceMs, options) {
+    if (connection2 === "connected") {
+      return {
+        formatted: options.palette.success(connection2),
+        unavailableFor: null,
+        stale: false
+      };
+    }
+    if (connection2 === "unknown") {
+      return {
+        formatted: options.palette.muted(connection2),
+        unavailableFor: null,
+        stale: false
+      };
+    }
+    const elapsedMs = notConnectedSinceMs === void 0 ? null : Math.max(0, options.nowMs - notConnectedSinceMs);
+    const unavailableFor = elapsedMs === null ? null : formatElapsed(elapsedMs);
+    const label2 = unavailableFor === null ? connection2 : `${connection2} (${unavailableFor})`;
+    const stale = elapsedMs !== null && elapsedMs >= options.connectionErrorAfterMs;
+    const tone = stale || connection2 === "disconnected" ? options.palette.error : options.palette.warning;
+    return {
+      formatted: tone(label2),
+      unavailableFor,
+      stale
+    };
+  }
+  function formatDaemonConnectivityStatus(connectivity, palette = defaultPalette) {
+    switch (connectivity) {
+      case "online":
+        return palette.success(connectivity);
+      case "reconnecting":
+        return palette.warning(connectivity);
+      case "offline":
+        return palette.error(connectivity);
+      default: {
+        const unreachable = connectivity;
+        return unreachable;
+      }
+    }
+  }
+  function formatDaemonBackendStatus(runtimeState, options = {}) {
+    const resolvedOptions = {
+      nowMs: options.nowMs ?? Date.now(),
+      connectionErrorAfterMs: options.connectionErrorAfterMs ?? DAEMON_CONNECTION_ERROR_AFTER_MS,
+      palette: options.palette ?? defaultPalette
+    };
+    const authorization = runtimeState.backend?.authorization ?? "unknown";
+    const backendConnection = formatConnection(runtimeState.backend?.connection ?? "unknown", runtimeState.connectionAges?.backendNotConnectedSinceMs, resolvedOptions);
     const lines2 = [
-      `  Backend Auth: ${runtimeState.backend?.authorization ?? "unknown"}`,
-      `  Backend Link: ${runtimeState.backend?.connection ?? "unknown"}`
+      `  Backend Auth: ${formatAuthorization(authorization, resolvedOptions.palette)}`,
+      `  Backend Link: ${backendConnection.formatted}`
     ];
+    if (backendConnection.stale && backendConnection.unavailableFor) {
+      lines2.push(resolvedOptions.palette.error(`  Backend Error: not connected for ${backendConnection.unavailableFor}`));
+    }
     if (!runtimeState.connectedWorkspaces) {
-      lines2.push("  Workspaces:   unavailable");
+      lines2.push(`  Workspaces:   ${resolvedOptions.palette.muted("unavailable")}`);
       return lines2;
     }
     lines2.push(`  Workspaces:   ${runtimeState.connectedWorkspaces.length}`);
     for (const workspace of runtimeState.connectedWorkspaces) {
       const label2 = workspace.slug ? `${workspace.name} (${workspace.slug})` : workspace.name;
+      const connection2 = formatConnection(workspace.backendConnection, runtimeState.connectionAges?.workspaceNotConnectedSinceMs?.[workspace.id], resolvedOptions);
       lines2.push(`    - ${label2} [${workspace.role}]`);
       lines2.push(`      ID: ${workspace.id}`);
-      lines2.push(`      Backend: ${workspace.backendConnection}`);
+      lines2.push(`      Backend: ${connection2.formatted}`);
+      if (connection2.stale && connection2.unavailableFor) {
+        lines2.push(resolvedOptions.palette.error(`      Error: not connected for ${connection2.unavailableFor}`));
+      }
     }
     return lines2;
   }
@@ -223567,7 +223801,7 @@ ${result.stdout ?? ""}`;
         };
       case "error":
         return {
-          status: "runner_error",
+          status: "startup_error",
           pid: result.runnerPid,
           message: result.message
         };
@@ -223582,7 +223816,7 @@ ${result.stdout ?? ""}`;
         };
       case "timeout":
         return {
-          status: "claim_timeout",
+          status: "startup_timeout",
           pid: result.runnerPid
         };
       default: {
@@ -223693,11 +223927,11 @@ ${result.stdout ?? ""}`;
       await exitDaemonCommand(1);
       return;
     }
-    if (result.status === "runner_error") {
+    if (result.status === "startup_error") {
       captureDaemonEvent("daemon_start_failed", {
-        reason_code: "runner_error"
+        reason_code: "startup_error"
       });
-      console.error(`Daemon runner (PID ${result.pid}) failed to start: ${result.message}`);
+      console.error(`Daemon startup (runner PID ${result.pid}) failed: ${result.message}`);
       await exitDaemonCommand(1);
       return;
     }
@@ -223705,15 +223939,15 @@ ${result.stdout ?? ""}`;
       captureDaemonEvent("daemon_start_failed", {
         reason_code: "runner_exited"
       });
-      console.error(`Daemon runner (PID ${result.pid}) exited before claiming ownership.`);
+      console.error(`Daemon runner (PID ${result.pid}) exited before its worker became ready.`);
       await exitDaemonCommand(1);
       return;
     }
-    if (result.status === "claim_timeout") {
+    if (result.status === "startup_timeout") {
       captureDaemonEvent("daemon_start_failed", {
-        reason_code: "claim_timeout"
+        reason_code: "startup_timeout"
       });
-      console.error(`Daemon runner (PID ${result.pid}) did not claim ownership in time.`);
+      console.error(`Daemon worker (PID ${result.pid}) did not become ready in time.`);
       await exitDaemonCommand(1);
       return;
     }
@@ -223775,9 +224009,9 @@ ${result.stdout ?? ""}`;
         console.log(`  Stage:        ${runtimeState.startupStage}`);
       }
       if (runtimeBelongsToDaemon && runtimeState.connectivity) {
-        console.log(`  Connectivity: ${runtimeState.connectivity}`);
+        console.log(`  Connectivity: ${formatDaemonConnectivityStatus(runtimeState.connectivity)}`);
       }
-      if (runtimeBelongsToDaemon) {
+      if (runtimeBelongsToDaemon && getCliPlatformKind() === "cloud") {
         for (const line3 of formatDaemonBackendStatus(runtimeState)) {
           console.log(line3);
         }
@@ -223910,18 +224144,18 @@ ${result.stdout ?? ""}`;
       await exitDaemonCommand(1);
       return;
     }
-    if (startResult.status === "runner_error") {
-      console.error(`Daemon runner (PID ${startResult.pid}) failed to start: ${startResult.message}`);
+    if (startResult.status === "startup_error") {
+      console.error(`Daemon startup (runner PID ${startResult.pid}) failed: ${startResult.message}`);
       await exitDaemonCommand(1);
       return;
     }
     if (startResult.status === "runner_exited") {
-      console.error(`Daemon runner (PID ${startResult.pid}) exited before claiming ownership.`);
+      console.error(`Daemon runner (PID ${startResult.pid}) exited before its worker became ready.`);
       await exitDaemonCommand(1);
       return;
     }
-    if (startResult.status === "claim_timeout") {
-      console.error(`Daemon runner (PID ${startResult.pid}) did not claim ownership in time.`);
+    if (startResult.status === "startup_timeout") {
+      console.error(`Daemon worker (PID ${startResult.pid}) did not become ready in time.`);
       await exitDaemonCommand(1);
       return;
     }
@@ -223933,6 +224167,23 @@ ${result.stdout ?? ""}`;
     await exitDaemonCommand(0);
     return;
   }));
+  const MAX_STARTUP_ERROR_CHARS = 2e3;
+  function isDaemonWorkerReady(state2) {
+    return state2.runtime?.startupStage === "ready" && state2.runtime.phase !== "fatal";
+  }
+  function isRetryableDaemonWorkerStartupExit(result) {
+    return result.code === EXIT_CODE_RETRYABLE_STARTUP;
+  }
+  function describeDaemonWorkerStartupFailure(result) {
+    const output = (result.stderr.trim() || result.stdout.trim()).split("\0").join("");
+    if (output) {
+      return output.length <= MAX_STARTUP_ERROR_CHARS ? output : `\u2026${output.slice(-MAX_STARTUP_ERROR_CHARS)}`;
+    }
+    if (result.signal) {
+      return `CLI worker exited from signal ${result.signal} before becoming ready`;
+    }
+    return `CLI worker exited with code ${result.code ?? "unknown"} before becoming ready`;
+  }
   function launchLodyStart(passthroughArgs, identity2) {
     const bin = resolveLodyBin();
     const args2 = [
@@ -224014,6 +224265,12 @@ ${result.stdout ?? ""}`;
       instanceId: randomUUID(),
       token: `${randomUUID()}${randomUUID()}`
     };
+    let launchOutcomePending = process.env[DAEMON_RUNNER_READY_FD_ENV] !== void 0;
+    const reportLaunchOutcome = (outcome) => {
+      if (!launchOutcomePending) return;
+      launchOutcomePending = false;
+      reportDaemonRunnerLaunchOutcome(outcome);
+    };
     let hostShutdownRequested = false;
     let hostShutdownHandler = null;
     const requestHostShutdown = () => {
@@ -224032,7 +224289,7 @@ ${result.stdout ?? ""}`;
     if (initialLease.status === "occupied") {
       const owner = initialLease.record ? `${initialLease.record.mode} process ${initialLease.record.pid}` : "another local CLI host";
       logger2.error(`Cannot start daemon: ${owner} already owns the local agent runtime.`);
-      reportDaemonRunnerLaunchOutcome({
+      reportLaunchOutcome({
         status: "occupied",
         ...initialLease.record ? {
           ownerMode: initialLease.record.mode,
@@ -224051,18 +224308,13 @@ ${result.stdout ?? ""}`;
       hostLease = null;
       const message = error2 instanceof Error ? error2.message : String(error2);
       logger2.error(`Failed to claim daemon ownership: ${message}`);
-      reportDaemonRunnerLaunchOutcome({
+      reportLaunchOutcome({
         status: "error",
         message
       });
       await flushTelemetry();
       process.exit(1);
     }
-    reportDaemonRunnerLaunchOutcome({
-      status: "ready",
-      pid: process.pid,
-      instanceId: supervisorIdentity.instanceId
-    });
     logger2.info(`Daemon watchdog started (PID ${process.pid})`);
     await normalizeCurrentProcessResourceProfile(logger2);
     for (const diagnostic of getRuntimeDiagnostics(version$9)) {
@@ -224189,6 +224441,17 @@ ${result.stdout ?? ""}`;
         }
       },
       decideExit: async (result, signal) => {
+        if (launchOutcomePending && !isRetryableDaemonWorkerStartupExit(result)) {
+          const message = describeDaemonWorkerStartupFailure(result);
+          reportLaunchOutcome({
+            status: "error",
+            message
+          });
+          return {
+            action: "fatal",
+            message: `Initial daemon worker startup failed: ${message}`
+          };
+        }
         if (result.code === 0) {
           return {
             action: "stop",
@@ -224256,6 +224519,13 @@ ${result.stdout ?? ""}`;
       },
       onStateChange: (state2) => {
         reportSupervisorAnalytics(state2);
+        if (launchOutcomePending && isDaemonWorkerReady(state2)) {
+          reportLaunchOutcome({
+            status: "ready",
+            pid: process.pid,
+            instanceId: supervisorIdentity.instanceId
+          });
+        }
         if (state2.phase === "fatal") {
           logger2.error(`Fatal: ${state2.message ?? "unknown"}`);
         } else if (state2.message) {
@@ -240485,6 +240755,8 @@ ${result.stdout ?? ""}`;
   const SESSION_CREATE_MANY_TOOL_NAME = "lody_session_create_many";
   const SESSION_CHAT_MANY_TOOL_NAME = "lody_session_chat_many";
   const SESSION_ARCHIVE_TOOL_NAME = "lody_session_archive";
+  const SESSION_RENAME_TOOL_NAME = "lody_session_rename";
+  const SESSION_RENAME_MANY_TOOL_NAME = "lody_session_rename_many";
   const OPERATION_GET_TOOL_NAME = "lody_operation_get";
   const OPERATION_CANCEL_TOOL_NAME = "lody_operation_cancel";
   const TASK_LIST_TOOL_NAME = "lody_task_list";
@@ -240509,6 +240781,7 @@ ${result.stdout ?? ""}`;
   const DEFAULT_MCP_SESSION_HISTORY_LIMIT = 10;
   const MAX_MCP_SESSION_HISTORY_LIMIT = 50;
   const MAX_MCP_SESSION_HISTORY_BYTES = 128 * 1024;
+  const MAX_MCP_SESSION_TITLE_CHARS = 200;
   const MAX_MCP_TASK_BODY_BYTES = 64 * 1024;
   const MAX_MCP_TASK_LINKS = 50;
   const MAX_MCP_TASK_EDIT_CHARS = 64e3;
@@ -240639,7 +240912,7 @@ ${result.stdout ?? ""}`;
     resume: boolean().optional().describe("Set to true to resume an accepted Operation without resending its input."),
     wait: literal$1(true).optional().describe("Wait for the assistant reply using the temporary legacy adapter."),
     timeoutSeconds: number$4().int().positive().max(MAX_MCP_SESSION_WAIT_TIMEOUT_SECONDS).optional().describe("Legacy wait timeout in seconds, up to one hour."),
-    useCurrentSessionAsParent: boolean().optional().describe("Create a child of the current Session; cannot be combined with workContext."),
+    useCurrentSessionAsParent: boolean().optional().describe("Create a child of the current Session that reuses the exact same workspace directory; cannot be combined with workContext."),
     workContext: SessionWorkContextInputSchema.optional().describe("Execution context for an independent Session; cannot be combined with useCurrentSessionAsParent=true.")
   }).strict().superRefine((value, ctx) => {
     const result = SessionCreateRuntimeInputSchema.safeParse(value);
@@ -240761,7 +241034,7 @@ ${result.stdout ?? ""}`;
   ]);
   const SessionCreateBatchPublishedItemSchema = object$1({
     ...SessionCreateBatchItemShape,
-    useCurrentSessionAsParent: boolean().optional().describe("Create a child of the current Session; cannot be combined with workContext."),
+    useCurrentSessionAsParent: boolean().optional().describe("Create a child of the current Session that reuses the exact same workspace directory; cannot be combined with workContext."),
     workContext: SessionWorkContextInputSchema.optional().describe("Execution context for an independent Session; cannot be combined with useCurrentSessionAsParent=true.")
   }).strict();
   const SessionCreateManyToolInputSchema = object$1({
@@ -240793,6 +241066,18 @@ ${result.stdout ?? ""}`;
   const SessionArchiveToolInputSchema = object$1({
     sessionId: string$1().trim().min(1)
   }).strict();
+  const SessionTitleToolInputSchema = string$1().trim().min(1).max(MAX_MCP_SESSION_TITLE_CHARS).describe(`New session title, up to ${MAX_MCP_SESSION_TITLE_CHARS} characters.`);
+  const SessionRenameToolInputSchema = object$1({
+    sessionId: string$1().trim().min(1).optional().describe("Target session id, or current. Defaults to current."),
+    title: SessionTitleToolInputSchema
+  }).strict();
+  const SessionRenameManyItemSchema = object$1({
+    sessionId: string$1().trim().min(1).describe("Target session id, or current."),
+    title: SessionTitleToolInputSchema
+  }).strict();
+  const SessionRenameManyToolInputSchema = object$1({
+    items: array$2(SessionRenameManyItemSchema).min(1).max(MAX_MCP_COMMAND_BATCH_SIZE).refine((items2) => new Set(items2.map((item) => item.sessionId)).size === items2.length, "sessionId values must be unique")
+  }).strict();
   const SessionStatusManyToolInputSchema = object$1({
     sessionIds: array$2(string$1().trim().min(1)).max(1e3).refine((items2) => new Set(items2).size === items2.length, "sessionIds must be unique")
   }).strict();
@@ -240907,30 +241192,22 @@ ${result.stdout ?? ""}`;
     } : {}
   });
   const jsonTextResult = (value, isError2 = false) => textResult(JSON.stringify(value, null, 2), isError2);
-  const mcpErrorResult = (error2) => {
+  const normalizeMcpError = (error2) => {
     if (error2 instanceof LodyOperationStoreError) {
-      return jsonTextResult({
-        ok: false,
-        error: error2.toLodyError()
-      }, true);
+      return error2.toLodyError();
     }
     if (error2 instanceof LocalDaemonAvailabilityError) {
-      return jsonTextResult({
-        ok: false,
-        error: error2.toLodyError()
-      }, true);
+      return error2.toLodyError();
     }
     if (error2 instanceof WorkspaceSyncUnavailableError) {
-      return jsonTextResult({
-        ok: false,
-        error: error2.toLodyError()
-      }, true);
+      return error2.toLodyError();
     }
-    return jsonTextResult({
-      ok: false,
-      error: makeLodyError("INTERNAL_ERROR", formatMcpErrorMessage(error2), false)
-    }, true);
+    return makeLodyError("INTERNAL_ERROR", formatMcpErrorMessage(error2), false);
   };
+  const mcpErrorResult = (error2) => jsonTextResult({
+    ok: false,
+    error: normalizeMcpError(error2)
+  }, true);
   const postSessionControl = async (request2, localControlSocketPath, timeoutMs = SESSION_CONTROL_TIMEOUT_MS) => {
     const responses = await runPromise(makeLocalControlClientAuto({
       socketPath: localControlSocketPath
@@ -242264,6 +242541,60 @@ ${prompt2}` : prompt2;
     }, worker));
     return output;
   };
+  const resolveSessionRenameItems = (items2, ctx) => {
+    assertBatchSize(items2.length, MAX_MCP_COMMAND_BATCH_SIZE);
+    const resolved = items2.map((item) => ({
+      sessionId: resolveMcpSessionId(item.sessionId, ctx),
+      title: item.title
+    }));
+    if (new Set(resolved.map((item) => item.sessionId)).size !== resolved.length) {
+      throw new LodyOperationStoreError("DUPLICATE_SESSION", "A session may appear only once in a rename batch.", false);
+    }
+    return resolved;
+  };
+  const applySessionRenameItems = async (items2, rename2) => await mapWithConcurrency(items2, 5, async (item) => {
+    try {
+      await rename2(item);
+      return {
+        sessionId: item.sessionId,
+        ok: true,
+        title: item.title
+      };
+    } catch (error2) {
+      return {
+        sessionId: item.sessionId,
+        ok: false,
+        error: normalizeMcpError(error2)
+      };
+    }
+  });
+  const persistSessionRenameItems = async (manager, items2, syncReason) => {
+    const results = await applySessionRenameItems(items2, async (item) => {
+      const session2 = await readCurrentSessionMeta(manager, item.sessionId);
+      if (!session2) {
+        throw new LodyOperationStoreError("SESSION_NOT_FOUND", `Session not found: ${item.sessionId}`, false);
+      }
+      await manager.repo.upsertDocMeta(getSessionRoomId(item.sessionId), {
+        title: item.title,
+        titleSource: "user"
+      });
+    });
+    if (results.some((item) => item.ok)) {
+      await ensureWorkspaceMetaSynced(manager, syncReason);
+    }
+    return results;
+  };
+  const renameSessionItems = async (input2) => {
+    const ctx = getSessionContext();
+    const resolved = resolveSessionRenameItems(input2.items, ctx);
+    const auth = getAuthContextOrThrow$1("mcp");
+    const workspace = await resolveWorkspaceOrThrow$1(auth, getMcpWorkspaceId(ctx));
+    return await withWorkspaceManager$1(auth, workspace, "mcp", async (manager) => {
+      const reason = `mcp.session_rename_many:${ctx.sessionId}`;
+      await syncWorkspaceMetaForRead(manager, reason);
+      return await persistSessionRenameItems(manager, resolved, reason);
+    });
+  };
   const buildOperationTargetCancelArgs = (workspaceId, item) => [
     "session",
     "cancel",
@@ -243244,6 +243575,41 @@ ${lines2.join("\n")}` : ""}${suffix}`);
         return mcpErrorResult(error2);
       }
     });
+    server.registerTool(SESSION_RENAME_TOOL_NAME, {
+      title: "Rename a Lody session",
+      description: "Set the title of one Session. Omit sessionId (or pass current) to rename the current Session. The durable rename is treated as a user-directed title and is not replaced by later automatic title generation.",
+      inputSchema: SessionRenameToolInputSchema
+    }, async (args2) => {
+      try {
+        const [item] = await renameSessionItems({
+          items: [
+            {
+              sessionId: args2.sessionId ?? "current",
+              title: args2.title
+            }
+          ]
+        });
+        if (!item) {
+          throw new Error("Session rename returned no result.");
+        }
+        return jsonTextResult(item, item.ok === false);
+      } catch (error2) {
+        return mcpErrorResult(error2);
+      }
+    });
+    server.registerTool(SESSION_RENAME_MANY_TOOL_NAME, {
+      title: "Rename multiple Lody sessions",
+      description: "Set titles for 1-20 Sessions. Session ids must be unique. Results preserve input order and failures are isolated per item; successful renames remain applied when another item fails.",
+      inputSchema: SessionRenameManyToolInputSchema
+    }, async (args2) => {
+      try {
+        return jsonTextResult({
+          items: await renameSessionItems(args2)
+        });
+      } catch (error2) {
+        return mcpErrorResult(error2);
+      }
+    });
     server.registerTool(SESSION_ARCHIVE_TOOL_NAME, {
       title: "Archive a Lody session",
       description: "Idempotently archive a Session. Archiving a parent cascades to child Sessions; pending Operation Deliveries remain pending until a human restores the Session.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lody",
-  "version": "0.89.4",
+  "version": "0.90.0",
   "description": "Lody Agent CLI tool for managing remote command execution",
   "type": "module",
   "main": "dist/index.js",