@love-moon/conductor-cli 0.11.1 → 0.11.2

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @love-moon/conductor-cli
 
+## 0.11.2
+
+### Patch Changes
+
+- 938efe7: Fix "New task from this" when the successor runs on a different daemon.
+
+  Picking another daemon in the dialog created the successor row and then killed
+  it one second later with `new task failed: Could not resolve resume cwd`. The
+  server intentionally drops the source machine's paths for a cross-daemon fork,
+  and the target daemon had nothing left to resolve: no launch-config `cwd`, no
+  worktree, no local project path (the default project has none, and a project
+  bound to another daemon is refused by design), and no source session in its own
+  session store.
+
+  Fork modes now fall back to a fresh `<workspace>/<date>/<run>` directory — the
+  same fallback `create_task` already uses — so the successor starts like a
+  brand-new task on that machine and picks up the conversation through the
+  resume-context URL. In-place restarts still fail loudly, because they must reuse
+  the original working directory.
+
+  - @love-moon/conductor-sdk@0.11.2
+  - @love-moon/ai-sdk@0.11.2
+
 ## 0.11.1
 
 ### Patch Changes

package/bin/conductor-config.js

@@ -415,8 +415,10 @@ async function main() {
     "# Optional features",
     "# ---------------------------------------------------------------------------",
     "",
-    "# Extra Codex auth.json files to switch between from the app's account",
-    "# picker. The file name (without .json) becomes the account name.",
+    "# Optional: extra Codex auth.json files to switch between from the app's",
+    "# account picker (shown only when more than one is listed). The file name",
+    "# (without .json) becomes the account name. Without this, quota comes from",
+    "# $CODEX_HOME/auth.json (default ~/.codex/auth.json).",
     "# ai_manager:",
     "#   codex:",
     "#     auth_json:",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.11.1",
-  "gitCommitId": "c174c7e",
+  "version": "0.11.2",
+  "gitCommitId": "067735d",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -24,8 +24,8 @@
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.11.1",
-    "@love-moon/conductor-sdk": "0.11.1",
+    "@love-moon/ai-sdk": "0.11.2",
+    "@love-moon/conductor-sdk": "0.11.2",
     "@github/copilot-sdk": "^0.3.0",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
@@ -38,7 +38,7 @@
   },
   "optionalDependencies": {
     "@roamhq/wrtc": "^0.10.0",
-    "@love-moon/chat-web": "0.11.1"
+    "@love-moon/chat-web": "0.11.2"
   },
   "pnpm": {
     "onlyBuiltDependencies": [

package/src/daemon.js

@@ -672,10 +672,102 @@ export function buildFireSpawnArgs({ selectedBackend, initialContent, launchConf
   if (effectivePrefill) {
     args.push("--prefill", effectivePrefill);
   }
+  const resumeSessionId =
+    normalizeOptionalString(launchConfig?.resumeSessionId) ||
+    normalizeOptionalString(launchConfig?.resume_session_id);
+  if (resumeSessionId) {
+    args.push("--resume", resumeSessionId);
+  }
   args.push("--");
   return args;
 }
 
+// Backends whose local session stores the ai-sdk resume module can enumerate.
+// Kept in sync with the server side of the `list_backend_sessions` RPC.
+const LISTABLE_SESSION_BACKENDS = ["claude", "codex", "kimi"];
+const DEFAULT_BACKEND_SESSION_LIMIT = 20;
+const MAX_BACKEND_SESSION_LIMIT = 50;
+
+// Lazy so a daemon running against an older ai-sdk build only fails when the
+// RPC is actually invoked (surfaced as a per-backend error), not at load time.
+async function listSessionsForBackendFromSdk(backendType, options) {
+  let sdk = await import("@love-moon/ai-sdk");
+  if (typeof sdk.listSessionsForBackend !== "function") {
+    // The root index can lag behind the resume module the function lives in;
+    // fall back to that entry point before declaring the sdk too old.
+    sdk = await import("@love-moon/ai-sdk/dist/resume/index.js").catch(() => sdk);
+  }
+  if (typeof sdk.listSessionsForBackend !== "function") {
+    throw new Error("Session listing is not supported by the installed ai-sdk");
+  }
+  return sdk.listSessionsForBackend(backendType, options);
+}
+
+/**
+ * Pure aggregation behind the `list_backend_sessions` RPC: intersect the
+ * requested backends with what this daemon supports, list each backend's
+ * sessions, and merge them newest-first. A single backend failing lands in
+ * `errors` without affecting the others. Exported so tests can drive it with
+ * a stubbed `listSessions`.
+ */
+export async function collectBackendSessions({
+  requestedBackends = null,
+  supportedBackends = [],
+  limit,
+  listSessions = listSessionsForBackendFromSdk,
+} = {}) {
+  const numericLimit = Number(limit);
+  const effectiveLimit =
+    Number.isFinite(numericLimit) && numericLimit > 0
+      ? Math.min(Math.floor(numericLimit), MAX_BACKEND_SESSION_LIMIT)
+      : DEFAULT_BACKEND_SESSION_LIMIT;
+  const listableBackends = LISTABLE_SESSION_BACKENDS.filter((backend) => supportedBackends.includes(backend));
+  const errors = [];
+  let backends;
+  if (Array.isArray(requestedBackends)) {
+    backends = [];
+    for (const raw of requestedBackends) {
+      const backend = typeof raw === "string" ? raw.trim().toLowerCase() : "";
+      if (!backend || backends.includes(backend)) {
+        continue;
+      }
+      if (!listableBackends.includes(backend)) {
+        errors.push({ backend, message: `Backend "${backend}" does not support session listing on this daemon` });
+        continue;
+      }
+      backends.push(backend);
+    }
+  } else {
+    backends = listableBackends;
+  }
+  const sessions = [];
+  for (const backend of backends) {
+    try {
+      const listed = await listSessions(backend, { limit: effectiveLimit });
+      for (const entry of Array.isArray(listed) ? listed : []) {
+        const sessionId = normalizeOptionalString(entry?.sessionId);
+        if (!sessionId) {
+          continue;
+        }
+        sessions.push({
+          backend,
+          session_id: sessionId,
+          session_file_path: normalizeOptionalString(entry?.sessionFilePath),
+          cwd: normalizeOptionalString(entry?.cwd),
+          title: normalizeOptionalString(entry?.title),
+          updated_at: Number.isFinite(entry?.updatedAt) ? new Date(entry.updatedAt).toISOString() : null,
+        });
+      }
+    } catch (error) {
+      errors.push({ backend, message: error?.message || String(error) });
+    }
+  }
+  // ISO 8601 strings compare lexicographically; entries without a timestamp
+  // sort last.
+  sessions.sort((a, b) => (b.updated_at || "").localeCompare(a.updated_at || ""));
+  return { sessions, errors };
+}
+
 function normalizeBooleanFlag(value) {
   if (typeof value === "boolean") {
     return value;
@@ -3663,6 +3755,7 @@ export function startDaemon(config = {}, deps = {}) {
     "restart_daemon",
     "refresh_session_inplace",
     "task_attachments_v1",
+    "backend_session_list",
     CUSTOM_COMMANDS_CAPABILITY,
     UPDATE_DAEMON_CAPABILITY,
   ];
@@ -6173,6 +6266,10 @@ export function startDaemon(config = {}, deps = {}) {
       void handleGetProjectAgents(event.payload);
       return;
     }
+    if (event.type === "list_backend_sessions") {
+      void handleListBackendSessions(event.payload);
+      return;
+    }
     if (event.type === "ai_manager_request") {
       // RFC 0035: reads are fine and genuinely useful to a guest (it needs to
       // know how much quota the borrowed machine has left). `switch_account` is
@@ -6551,6 +6648,42 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
+  async function handleListBackendSessions(payload) {
+    const requestId = payload?.request_id ? String(payload.request_id).trim() : "";
+    if (!requestId) {
+      logError(`Invalid list_backend_sessions payload: ${JSON.stringify(payload)}`);
+      return;
+    }
+
+    let result;
+    try {
+      result = await collectBackendSessions({
+        requestedBackends: Array.isArray(payload?.backends) ? payload.backends : null,
+        supportedBackends: SUPPORTED_BACKENDS,
+        limit: payload?.limit,
+        listSessions: deps.listBackendSessions,
+      });
+    } catch (error) {
+      result = {
+        sessions: [],
+        errors: [{ backend: "*", message: `Failed to list backend sessions on daemon ${AGENT_NAME}: ${error?.message || error}` }],
+      };
+    }
+
+    try {
+      await client.sendJson({
+        type: "backend_sessions_listed",
+        payload: {
+          request_id: requestId,
+          sessions: result.sessions,
+          errors: result.errors,
+        },
+      });
+    } catch (error) {
+      logError(`Failed to report backend_sessions_listed for ${requestId}: ${error?.message || error}`);
+    }
+  }
+
   function stopActiveTaskProcess(
     taskId,
     {
@@ -7940,6 +8073,31 @@ export function startDaemon(config = {}, deps = {}) {
       return;
     }
 
+    if (!resolvedResumeCwd && isForkMode) {
+      // A fork starts a brand-new session and receives its context as a URL, so
+      // it does not need the source task's files. When nothing in the chain
+      // resolves — the normal case for a cross-daemon fork, where the server
+      // drops the source machine's paths and this daemon holds no local path
+      // for the project — land in a fresh workspace dir exactly like
+      // create_task does, instead of killing the successor on arrival.
+      const now = new Date();
+      // Keyed off the task id, not the daemon pid: the run timestamp only has
+      // second granularity and this path never renames the dir afterwards
+      // (create_task does), so two forks landing in the same second would
+      // otherwise share one workspace AND one conductor.log.
+      const taskSuffix =
+        normalizedTargetTaskId.replace(/[^a-zA-Z0-9]/g, "").slice(0, 8) || String(process.pid);
+      resolvedResumeCwd = path.join(
+        WORKSPACE_ROOT,
+        formatWorkspaceDate(now),
+        `${formatWorkspaceRunTimestamp(now)}_fork_${taskSuffix}`,
+      );
+      log(
+        `No local workspace for project ${normalizedProjectId} on this daemon; ` +
+          `forking task ${normalizedTargetTaskId} into ${resolvedResumeCwd}`,
+      );
+    }
+
     if (!resolvedResumeCwd) {
       reportRestartFailure({
         taskId: normalizedTargetTaskId,