@makerbi/remodex 1.5.4 → 1.5.8

package/src/codex-transport.js

@@ -13,6 +13,7 @@ function createCodexTransport({
   endpoint = "",
   env = process.env,
   appPath = "",
+  platform = process.platform,
   spawnImpl = spawn,
   WebSocketImpl = WebSocket,
 } = {}) {
@@ -20,11 +21,11 @@ function createCodexTransport({
     return createWebSocketTransport({ endpoint, WebSocketImpl });
   }
 
-  return createSpawnTransport({ env, appPath, spawnImpl });
+  return createSpawnTransport({ env, appPath, platform, spawnImpl });
 }
 
-function createSpawnTransport({ env, appPath, spawnImpl = spawn }) {
-  const launchPlans = createCodexLaunchPlans({ env, appPath });
+function createSpawnTransport({ env, appPath, platform, spawnImpl = spawn }) {
+  const launchPlans = createCodexLaunchPlans({ env, appPath, platform });
   let launchIndex = -1;
   let activeLaunch = null;
   let codex = null;
@@ -154,13 +155,12 @@ function createSpawnTransport({ env, appPath, spawnImpl = spawn }) {
         return;
       }
       stdoutBuffer += chunk.toString("utf8");
-      const lines = stdoutBuffer.split("\n");
-      stdoutBuffer = lines.pop() || "";
-
-      for (const line of lines) {
-        const trimmedLine = line.trim();
-        if (trimmedLine) {
-          listeners.emitMessage(trimmedLine);
+      let newlineIndex;
+      while ((newlineIndex = stdoutBuffer.indexOf("\n")) !== -1) {
+        const line = stdoutBuffer.substring(0, newlineIndex).trim();
+        stdoutBuffer = stdoutBuffer.substring(newlineIndex + 1);
+        if (line) {
+          listeners.emitMessage(line);
         }
       }
     });

package/src/desktop-handler.js

@@ -1,5 +1,5 @@
 // FILE: desktop-handler.js
-// Purpose: Handles explicit desktop handoff, display wake, and bridge preference RPCs for Codex.app.
+// Purpose: Handles explicit desktop handoff, display wake, bridge update, and preference RPCs for Codex.app.
 // Layer: Bridge handler
 // Exports: handleDesktopRequest
 // Depends on: child_process, fs, os, path, ./rollout-watch
@@ -126,6 +126,8 @@ async function handleDesktopMethod(method, params, options = {}) {
       return readBridgePreferences(options);
     case "desktop/preferences/update":
       return updateBridgePreferences(params, options);
+    case "desktop/bridge/updateAndRestart":
+      return updateBridgePackageAndRestart(options);
     default:
       throw desktopError("unknown_method", `Unknown desktop method: ${method}`);
   }
@@ -360,6 +362,17 @@ async function updateBridgePreferences(params, options = {}) {
   });
 }
 
+async function updateBridgePackageAndRestart(options = {}) {
+  if (typeof options.updateBridgePackageAndRestart !== "function") {
+    throw desktopError(
+      "unsupported_bridge_update",
+      "This bridge does not support iPhone-triggered bridge updates yet."
+    );
+  }
+
+  return options.updateBridgePackageAndRestart();
+}
+
 function resolveThreadId(params) {
   if (!params || typeof params !== "object") {
     return "";

package/src/desktop-ipc-action-follower.js

@@ -11,6 +11,7 @@ const path = require("path");
 const FRAME_HEADER_BYTES = 4;
 const MAX_FRAME_BYTES = 256 * 1024 * 1024;
 const REQUEST_TIMEOUT_MS = 10_000;
+const DESKTOP_IPC_ACTION_SOURCE = "desktop-ipc-action-follower";
 const DESKTOP_RESUME_METHODS = new Set(["thread/read", "thread/resume"]);
 const ACTION_METHODS = new Set([
   "item/commandExecution/requestApproval",
@@ -54,6 +55,7 @@ function createDesktopIpcActionFollower({
     onDisconnect,
   });
   const rawStatesByThreadId = new Map();
+  const assistantMessageTextsByThreadId = new Map();
   const pendingRoutesByRequestId = new Map();
   const activeThreadIds = new Set();
   const recoveringThreadIds = new Set();
@@ -84,6 +86,7 @@ function createDesktopIpcActionFollower({
 
   function stopAll() {
     rawStatesByThreadId.clear();
+    assistantMessageTextsByThreadId.clear();
     pendingRoutesByRequestId.clear();
     activeThreadIds.clear();
     recoveringThreadIds.clear();
@@ -132,11 +135,13 @@ function createDesktopIpcActionFollower({
     }
 
     rawStatesByThreadId.set(threadId, nextState);
+    syncProjectedAssistantDeltas(threadId, previousState, nextState);
     syncProjectedActions(threadId, projectPendingDesktopActions(threadId, nextState));
   }
 
   function onDisconnect() {
     rawStatesByThreadId.clear();
+    assistantMessageTextsByThreadId.clear();
     pendingRoutesByRequestId.clear();
     recoveringThreadIds.clear();
     queuedChangesByThreadId.clear();
@@ -273,9 +278,34 @@ function createDesktopIpcActionFollower({
     }
 
     rawStatesByThreadId.set(threadId, nextState);
+    syncProjectedAssistantDeltas(threadId, baselineState, nextState);
     syncProjectedActions(threadId, projectPendingDesktopActions(threadId, nextState));
   }
 
+  function syncProjectedAssistantDeltas(threadId, previousState, nextState) {
+    const previousTexts = assistantMessageTextsByThreadId.get(threadId);
+    if (!previousTexts && !previousState) {
+      assistantMessageTextsByThreadId.set(threadId, snapshotAssistantMessageTexts(nextState));
+      return;
+    }
+
+    const notifications = projectDesktopAssistantDeltaNotifications(
+      threadId,
+      previousState,
+      nextState,
+      previousTexts || snapshotAssistantMessageTexts(previousState)
+    );
+    if (notifications.length === 0) {
+      assistantMessageTextsByThreadId.set(threadId, snapshotAssistantMessageTexts(nextState));
+      return;
+    }
+
+    for (const notification of notifications) {
+      sendApplicationResponse(JSON.stringify(notification));
+    }
+    assistantMessageTextsByThreadId.set(threadId, snapshotAssistantMessageTexts(nextState));
+  }
+
   return {
     observeInbound,
     stopAll,
@@ -550,6 +580,93 @@ function projectPendingDesktopActions(threadId, conversationState) {
     .filter(Boolean);
 }
 
+// Desktop IPC exposes full conversation snapshots/patches, not app-server assistant delta events.
+// Mirror only suffix growth for assistant rows so phones can render the same live text progression.
+function projectDesktopAssistantDeltaNotifications(
+  threadId,
+  previousState,
+  nextState,
+  previousTexts = snapshotAssistantMessageTexts(previousState)
+) {
+  const nextMessages = collectAssistantMessages(nextState);
+  const notifications = [];
+
+  for (const message of nextMessages) {
+    const previousText = previousTexts.get(message.key) || "";
+    if (!message.text || !message.text.startsWith(previousText) || message.text.length <= previousText.length) {
+      continue;
+    }
+
+    const delta = message.text.slice(previousText.length);
+    notifications.push({
+      method: "item/agentMessage/delta",
+      params: {
+        threadId,
+        turnId: message.turnId,
+        itemId: message.itemId,
+        delta,
+      },
+    });
+  }
+
+  return notifications;
+}
+
+function snapshotAssistantMessageTexts(conversationState) {
+  return new Map(collectAssistantMessages(conversationState).map((message) => [message.key, message.text]));
+}
+
+function collectAssistantMessages(conversationState) {
+  const turns = Array.isArray(conversationState?.turns) ? conversationState.turns : [];
+  const messages = [];
+  for (const turn of turns) {
+    const turnId = readString(turn?.id) || readString(turn?.turnId) || readString(turn?.turn_id);
+    const items = Array.isArray(turn?.items) ? turn.items : [];
+    for (const item of items) {
+      if (!isAssistantMessageItem(item)) {
+        continue;
+      }
+
+      const itemId = readString(item?.id) || readString(item?.itemId) || readString(item?.item_id);
+      const text = assistantMessageText(item);
+      if (!turnId || !itemId) {
+        continue;
+      }
+
+      messages.push({
+        key: `${turnId}:${itemId}`,
+        turnId,
+        itemId,
+        text,
+      });
+    }
+  }
+  return messages;
+}
+
+function isAssistantMessageItem(item) {
+  const type = normalizeToken(item?.type);
+  if (type === "agentmessage" || type === "assistantmessage") {
+    return true;
+  }
+  return type === "message" && normalizeToken(item?.role) === "assistant";
+}
+
+function assistantMessageText(item) {
+  const directText = readString(item?.text) || readString(item?.message);
+  if (directText) {
+    return directText;
+  }
+
+  const content = Array.isArray(item?.content) ? item.content : [];
+  return content
+    .map((entry) => entry && typeof entry === "object" ? entry : null)
+    .filter(Boolean)
+    .map((entry) => readString(entry.text) || readString(entry?.data?.text))
+    .filter(Boolean)
+    .join("");
+}
+
 function projectPendingDesktopAction(threadId, request) {
   const requestId = requestIdKey(request.id);
   const method = readString(request.method);
@@ -572,6 +689,7 @@ function projectPendingDesktopAction(threadId, request) {
     method,
     params: {
       ...params,
+      remodexActionSource: DESKTOP_IPC_ACTION_SOURCE,
       threadId: readString(params.threadId) || readString(params.thread_id) || threadId,
     },
   };
@@ -674,6 +792,10 @@ function writeFrame(socket, payload, callback) {
 }
 
 function resolveDefaultIpcSocketPath() {
+  if (process.platform === "win32") {
+    return "\\\\.\\pipe\\codex-ipc";
+  }
+
   const uid = typeof process.getuid === "function" ? process.getuid() : 0;
   return path.join(os.tmpdir(), "codex-ipc", `ipc-${uid}.sock`);
 }
@@ -699,6 +821,12 @@ function readString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
 }
 
+function normalizeToken(value) {
+  return typeof value === "string"
+    ? value.toLowerCase().replace(/[_-\s]+/g, "")
+    : "";
+}
+
 function cloneJSON(value) {
   return JSON.parse(JSON.stringify(value));
 }
@@ -715,6 +843,7 @@ module.exports = {
   applyConversationStateChange,
   createDesktopIpcActionFollower,
   desktopFollowerPayloadForResponse,
+  projectDesktopAssistantDeltaNotifications,
   projectPendingDesktopActions,
   resolveDefaultIpcSocketPath,
   seedConversationStateFromThreadRead,

package/src/index.js

@@ -5,7 +5,7 @@
 // Depends on: ./bridge, ./secure-device-state, ./session-state, ./rollout-watch, ./macos-launch-agent
 
 const { startBridge } = require("./bridge");
-const { readBridgeDeviceState, resetBridgeDeviceState } = require("./secure-device-state");
+const { readBridgeDeviceState, resetBridgeTrustState } = require("./secure-device-state");
 const { openLastActiveThread } = require("./session-state");
 const { watchThreadRollout } = require("./rollout-watch");
 const { readBridgeConfig } = require("./codex-desktop-refresher");
@@ -14,6 +14,7 @@ const {
   printMacOSBridgePairingQr,
   printMacOSBridgeServiceStatus,
   resetMacOSBridgePairing,
+  restartMacOSBridgeService,
   runMacOSBridgeService,
   startMacOSBridgeService,
   stopMacOSBridgeService,
@@ -26,11 +27,12 @@ module.exports = {
   readBridgeConfig,
   readBridgeDeviceState,
   resetMacOSBridgePairing,
+  restartMacOSBridgeService,
   startBridge,
   runMacOSBridgeService,
   startMacOSBridgeService,
   stopMacOSBridgeService,
-  resetBridgePairing: resetBridgeDeviceState,
+  resetBridgePairing: resetBridgeTrustState,
   openLastActiveThread,
   watchThreadRollout,
 };

package/src/macos-launch-agent.js

@@ -11,7 +11,7 @@ const path = require("path");
 const { startBridge } = require("./bridge");
 const { readBridgeConfig } = require("./codex-desktop-refresher");
 const { printQR } = require("./qr");
-const { resetBridgeDeviceState } = require("./secure-device-state");
+const { resetBridgeTrustState } = require("./secure-device-state");
 const {
   clearBridgeStatus,
   clearPairingSession,
@@ -122,6 +122,65 @@ async function startMacOSBridgeService({
   };
 }
 
+// Restarts the installed LaunchAgent without rewriting relay config, useful during local bridge development.
+async function restartMacOSBridgeService({
+  env = process.env,
+  platform = process.platform,
+  fsImpl = fs,
+  execFileSyncImpl = execFileSync,
+  osImpl = os,
+  waitForPairing = false,
+  pairingTimeoutMs = DEFAULT_PAIRING_WAIT_TIMEOUT_MS,
+  pairingPollIntervalMs = DEFAULT_PAIRING_WAIT_INTERVAL_MS,
+  ...startOptions
+} = {}) {
+  assertDarwinPlatform(platform);
+  const plistPath = resolveLaunchAgentPlistPath({ env, osImpl });
+  if (!fsImpl.existsSync(plistPath)) {
+    return startMacOSBridgeService({
+      env,
+      platform,
+      fsImpl,
+      execFileSyncImpl,
+      osImpl,
+      waitForPairing,
+      pairingTimeoutMs,
+      pairingPollIntervalMs,
+      ...startOptions,
+    });
+  }
+
+  const startedAt = Date.now();
+  if (waitForPairing) {
+    clearPairingSession({ env, fsImpl });
+  }
+
+  kickstartLaunchAgent({
+    env,
+    execFileSyncImpl,
+    plistPath,
+  });
+
+  if (waitForPairing) {
+    const pairingSession = await waitForFreshPairingSession({
+      env,
+      fsImpl,
+      startedAt,
+      timeoutMs: pairingTimeoutMs,
+      intervalMs: pairingPollIntervalMs,
+    });
+    return {
+      plistPath,
+      pairingSession,
+    };
+  }
+
+  return {
+    plistPath,
+    pairingSession: null,
+  };
+}
+
 function stopMacOSBridgeService({
   env = process.env,
   platform = process.platform,
@@ -150,7 +209,7 @@ function resetMacOSBridgePairing({
   platform = process.platform,
   execFileSyncImpl = execFileSync,
   fsImpl = fs,
-  resetBridgePairingImpl = resetBridgeDeviceState,
+  resetBridgePairingImpl = resetBridgeTrustState,
 } = {}) {
   assertDarwinPlatform(platform);
   stopMacOSBridgeService({
@@ -388,6 +447,31 @@ function restartLaunchAgent({
   ], { stdio: ["ignore", "ignore", "pipe"] });
 }
 
+function kickstartLaunchAgent({
+  env = process.env,
+  execFileSyncImpl = execFileSync,
+  plistPath,
+} = {}) {
+  try {
+    execFileSyncImpl("launchctl", [
+      "kickstart",
+      "-k",
+      launchAgentLabelDomain(env),
+    ], { stdio: ["ignore", "ignore", "pipe"] });
+  } catch {
+    execFileSyncImpl("launchctl", [
+      "bootstrap",
+      launchAgentDomain(env),
+      plistPath,
+    ], { stdio: ["ignore", "ignore", "pipe"] });
+    execFileSyncImpl("launchctl", [
+      "kickstart",
+      "-k",
+      launchAgentLabelDomain(env),
+    ], { stdio: ["ignore", "ignore", "pipe"] });
+  }
+}
+
 function bootoutLaunchAgent({
   env = process.env,
   execFileSyncImpl = execFileSync,
@@ -552,6 +636,7 @@ module.exports = {
   printMacOSBridgeServiceStatus,
   resetMacOSBridgePairing,
   resolveLaunchAgentPlistPath,
+  restartMacOSBridgeService,
   runMacOSBridgeService,
   startMacOSBridgeService,
   stopMacOSBridgeService,

package/src/project-handler.js

@@ -2,11 +2,12 @@
 // Purpose: Serves safe Mac-local project folder discovery and creation requests from the iOS app.
 // Layer: Bridge handler
 // Exports: handleProjectRequest plus testable project filesystem helpers
-// Depends on: fs, os, path
+// Depends on: fs, os, path, ./codex-home
 
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
+const { resolveCodexHome } = require("./codex-home");
 
 const DEFAULT_DIRECTORY_LIMIT = 200;
 const DEFAULT_DIRECTORY_SEARCH_LIMIT = 80;
@@ -14,6 +15,14 @@ const DEFAULT_DIRECTORY_SEARCH_MAX_DEPTH = 8;
 const DEFAULT_DIRECTORY_SEARCH_MAX_VISITED = 5000;
 const DEFAULT_HIDDEN_DIRECTORY_NAMES = new Set(["Library"]);
 
+// Rootless chat slug rules mirror Codex Desktop's `~/Documents/Codex/<DATE>/<slug>`
+// convention so iOS-created Quick Chats land in the same bucket Desktop classifies
+// as projectless.
+const ROOTLESS_CHAT_SLUG_MAX_TOKENS = 6;
+const ROOTLESS_CHAT_SLUG_MAX_LENGTH = 60;
+const ROOTLESS_CHAT_SLUG_FALLBACK = "new-chat";
+const ROOTLESS_CHAT_DEDUP_LIMIT = 50;
+
 // ─── ENTRY POINT ─────────────────────────────────────────────
 
 function handleProjectRequest(rawMessage, sendResponse) {
@@ -58,6 +67,8 @@ async function handleProjectMethod(method, params, options = {}) {
   switch (method) {
     case "project/quickLocations":
       return projectQuickLocations(options);
+    case "project/projectlessRoots":
+      return projectProjectlessRoots(options);
     case "project/listDirectory":
       return projectListDirectory(params, options);
     case "project/searchDirectories":
@@ -66,6 +77,8 @@ async function handleProjectMethod(method, params, options = {}) {
       return projectValidatePath(params, options);
     case "project/createDirectory":
       return projectCreateDirectory(params, options);
+    case "project/createRootlessChatRoot":
+      return projectCreateRootlessChatRoot(params, options);
     default:
       throw projectError("unknown_method", `Unknown project method: ${method}`);
   }
@@ -99,6 +112,24 @@ async function projectQuickLocations(options = {}) {
   return { locations };
 }
 
+async function projectProjectlessRoots(options = {}) {
+  const homeDir = resolveHomeDir(options);
+  const codexHome = path.resolve(readString(options.codexHome) || resolveCodexHome());
+  const documentedThreadsRoot = path.join(codexHome, "threads");
+  const desktopDocumentsRoot = path.join(homeDir, "Documents", "Codex");
+  const roots = uniqueExistingOrCandidatePaths([
+    documentedThreadsRoot,
+    desktopDocumentsRoot,
+  ]);
+
+  return {
+    codexHome,
+    roots,
+    documentedThreadsRoot,
+    desktopDocumentsRoot,
+  };
+}
+
 async function projectListDirectory(params, options = {}) {
   const requestedPath = readString(params.path) || resolveHomeDir(options);
   const directory = await requireUsableDirectory(requestedPath, options);
@@ -184,6 +215,116 @@ async function projectCreateDirectory(params, options = {}) {
   };
 }
 
+// Mirrors the Codex Desktop "Chats" convention by materializing a dated rootless
+// chat folder under `~/Documents/Codex/<DATE>/<slug>` (or its Windows equivalent
+// `%USERPROFILE%\Documents\Codex\<DATE>\<slug>`) before the iOS client issues
+// `thread/start`. Without an explicit cwd the app-server falls back to its own
+// process working directory (often the user's home), which would otherwise show
+// up in the sidebar as a project named after the user account.
+async function projectCreateRootlessChatRoot(params = {}, options = {}) {
+  const homeDir = resolveHomeDir(options);
+  const desktopDocumentsRoot = path.join(homeDir, "Documents", "Codex");
+  const dateFolder = readString(params.dateFolder) || formatRootlessChatDate(new Date());
+  if (!isISODateFolderName(dateFolder)) {
+    throw projectError("invalid_date_folder", "The chat date folder must be in YYYY-MM-DD format.");
+  }
+
+  const slugBase = rootlessChatSlugFromPromptHint(params.promptHint);
+  const dateRootPath = path.join(desktopDocumentsRoot, dateFolder);
+
+  try {
+    await fs.promises.mkdir(dateRootPath, { recursive: true });
+  } catch (error) {
+    throw projectError("create_failed", error?.message || "Unable to prepare the Codex chats folder.");
+  }
+
+  const targetPath = await reserveUniqueRootlessChatPath(dateRootPath, slugBase);
+  try {
+    await fs.promises.mkdir(targetPath, { recursive: false });
+  } catch (error) {
+    if (error?.code !== "EEXIST") {
+      throw projectError("create_failed", error?.message || "Unable to create the rootless chat folder.");
+    }
+  }
+
+  const resolvedPath = await safeRealpath(targetPath);
+  return {
+    path: resolvedPath,
+    parentPath: dateRootPath,
+    name: path.basename(resolvedPath),
+    slug: slugBase,
+    dateFolder,
+    root: desktopDocumentsRoot,
+  };
+}
+
+// Codex Desktop generates kebab-case slugs from the first words of the prompt
+// (e.g. "mi-dici-la-pwd-corrente" from "mi dici la pwd corrente?"). We mirror
+// the same shape so that side-by-side users with the desktop app see a
+// consistent chat folder naming scheme.
+function rootlessChatSlugFromPromptHint(rawPromptHint) {
+  const hint = typeof rawPromptHint === "string" ? rawPromptHint.normalize("NFKD") : "";
+  const sanitized = hint
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/gu, " ")
+    .trim();
+  if (!sanitized) {
+    return ROOTLESS_CHAT_SLUG_FALLBACK;
+  }
+
+  const tokens = sanitized
+    .split(/\s+/)
+    .filter(Boolean)
+    .slice(0, ROOTLESS_CHAT_SLUG_MAX_TOKENS);
+  if (!tokens.length) {
+    return ROOTLESS_CHAT_SLUG_FALLBACK;
+  }
+
+  let slug = tokens.join("-");
+  if (slug.length > ROOTLESS_CHAT_SLUG_MAX_LENGTH) {
+    slug = slug.slice(0, ROOTLESS_CHAT_SLUG_MAX_LENGTH).replace(/-+$/g, "");
+  }
+  return slug || ROOTLESS_CHAT_SLUG_FALLBACK;
+}
+
+// Appends "-2", "-3", … so two rapid-fire chats with the same first words
+// keep distinct folders instead of fighting over the same path.
+async function reserveUniqueRootlessChatPath(parentDirectory, slugBase) {
+  for (let attempt = 0; attempt < ROOTLESS_CHAT_DEDUP_LIMIT; attempt += 1) {
+    const candidateSlug = attempt === 0 ? slugBase : `${slugBase}-${attempt + 1}`;
+    const candidatePath = path.join(parentDirectory, candidateSlug);
+    try {
+      await fs.promises.access(candidatePath, fs.constants.F_OK);
+    } catch {
+      return candidatePath;
+    }
+  }
+
+  return path.join(parentDirectory, `${slugBase}-${Date.now()}`);
+}
+
+function formatRootlessChatDate(date) {
+  const year = date.getFullYear().toString().padStart(4, "0");
+  const month = (date.getMonth() + 1).toString().padStart(2, "0");
+  const day = date.getDate().toString().padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+function isISODateFolderName(value) {
+  if (typeof value !== "string" || value.length !== 10) {
+    return false;
+  }
+  return /^\d{4}-\d{2}-\d{2}$/u.test(value);
+}
+
+async function safeRealpath(candidatePath) {
+  try {
+    return await fs.promises.realpath(candidatePath);
+  } catch {
+    return path.resolve(candidatePath);
+  }
+}
+
 // ─── Filesystem Helpers ──────────────────────────────────────
 
 async function readDirectoryEntries(directoryPath, options = {}) {
@@ -462,6 +603,23 @@ function resolveHomeDir(options = {}) {
   return options.homeDir || os.homedir();
 }
 
+function uniqueExistingOrCandidatePaths(paths) {
+  const seen = new Set();
+  const result = [];
+
+  for (const candidatePath of paths) {
+    const normalizedPath = path.resolve(candidatePath);
+    const realPath = realpathSyncIfAvailable(normalizedPath) || normalizedPath;
+    if (seen.has(realPath)) {
+      continue;
+    }
+    seen.add(realPath);
+    result.push(realPath);
+  }
+
+  return result;
+}
+
 function realpathSyncIfAvailable(candidatePath) {
   try {
     return fs.realpathSync(candidatePath);
@@ -485,9 +643,12 @@ module.exports = {
   handleProjectRequest,
   handleProjectMethod,
   projectQuickLocations,
+  projectProjectlessRoots,
   projectListDirectory,
   projectSearchDirectories,
   projectValidatePath,
   projectCreateDirectory,
+  projectCreateRootlessChatRoot,
   validateDirectory,
+  rootlessChatSlugFromPromptHint,
 };