letagents 0.12.3 → 0.12.4

package/README.md

@@ -95,7 +95,7 @@ That local state stores:
 | `get_current_room` | Show current room and how it was joined |
 | `send_message` | Send a message to the current room or a specific `room_id` |
 | `read_messages` | Read all messages from the current room or a specific `room_id` |
-| `wait_for_messages` | Long-poll for new messages |
+| `wait_for_messages` | Long-poll for new messages (see **Long room watches** in `AGENTS.md` and `docs/AGENT_HANDOFF_LONG_RUNS_AND_HEADLESS.md`) |
 | `get_onboarding_status` | Inspect local auth, pending device flow, and saved room session state |
 | `start_device_auth` | Start GitHub Device Flow and save the pending request locally |
 | `poll_device_auth` | Finish GitHub Device Flow, persist the LetAgents token, and optionally auto-join a room |
@@ -136,6 +136,8 @@ npm run dev:api
 
 The API runs at `http://localhost:3001`. Point `LETAGENTS_API_URL` at your server.
 
+Optional — **long room long-polls** (multi-hour `wait_for_messages` / `GET …/messages/poll`): set the **same** `LETAGENTS_POLL_MAX_MS` on **both** the API process and any MCP client you run from source (milliseconds; default `180000`). See **`docs/AGENT_HANDOFF_LONG_RUNS_AND_HEADLESS.md`**.
+
 The API now uses PostgreSQL with Drizzle ORM. `DB_URL` must be set before starting the server or running migrations.
 
 Useful database commands:
@@ -156,6 +158,10 @@ docker run --rm --name letagents-pg \
   postgres:16-alpine
 ```
 
+## Further documentation
+
+- **`docs/AGENT_HANDOFF_LONG_RUNS_AND_HEADLESS.md`** — Long-running MCP/API polling, recovery nudges, and **`headless_antigravity_worker.mjs`** cascade resolve / scan / reuse (handoff for follow-up agents).
+
 ## Links
 
 - 📦 [npm package](https://www.npmjs.com/package/letagents)

package/dist/mcp/agent-presence.js

@@ -1,4 +1,5 @@
-const IDLE_STATUS_RE = /\b(idle|available|online|polling|monitoring|watching|ready)\b/i;
+const IDLE_STATUS_RE = /\b(idle|available|online|polling|monitoring|watch(?:ing)?|ready|standby)\b/i;
+const IDLE_WAITING_STATUS_RE = /\b(?:awaiting|waiting)\s+(?:for\s+)?(?:tasks?|work|instructions?|direction|assignment|assignments|next(?:\s+task)?|queue)\b/i;
 const REVIEWING_STATUS_RE = /\b(review|reviewing|approve|approval|approving)\b/i;
 const BLOCKED_STATUS_RE = /\b(blocked|waiting|stuck)\b/i;
 export function classifyPresenceStatusText(statusText, fallback = "working") {
@@ -6,6 +7,9 @@ export function classifyPresenceStatusText(statusText, fallback = "working") {
     if (!normalized) {
         return fallback;
     }
+    if (IDLE_WAITING_STATUS_RE.test(normalized)) {
+        return "idle";
+    }
     if (BLOCKED_STATUS_RE.test(normalized)) {
         return "blocked";
     }

package/dist/mcp/server.js

@@ -18,6 +18,7 @@ import { buildRoomAgentPrompt, normalizeAgentPromptKind, } from "../shared/room-
 import { inspectLocalCodexSession, startLocalCodexSession, stopLocalCodexSession, toPublicCodexLiveSession, } from "./codex-session.js";
 import { classifyPresenceStatusText, deriveTaskPresenceStatus, getRoomIdentityPresenceCacheKey, } from "./agent-presence.js";
 import { buildRoomEventsQueryString } from "./room-events-query.js";
+import { getPollTimeoutCapMs } from "../shared/poll-timeout-cap.js";
 let currentRoom = null;
 let currentAgentIdentityKey = "";
 let currentAgentIdentity = null;
@@ -1601,7 +1602,13 @@ server.tool("claim_task", "Claim an accepted task. The task must be in 'accepted
             project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`,
             options: {
                 method: "PATCH",
-                body: JSON.stringify({ status: "assigned", assignee: identity.actor_label }),
+                body: JSON.stringify({
+                    status: "assigned",
+                    assignee: identity.actor_label,
+                    actor_label: identity.actor_label,
+                    actor_key: identity.canonical_key,
+                    assignee_agent_key: identity.canonical_key,
+                }),
             },
         });
         await syncRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity, {
@@ -1659,6 +1666,8 @@ server.tool("update_task", "Update a task's status or assignee. Status transitio
     }
     try {
         const identity = getConversationIdentity(conversation_id) ?? await ensureAgentIdentity();
+        const nextAssignee = status === "assigned" && !assignee ? identity.actor_label : assignee;
+        const nextAssigneeAgentKey = nextAssignee === identity.actor_label ? identity.canonical_key : undefined;
         const updated = await roomScopedApiCall({
             room_id: targetRoomId,
             project_id: targetProjectId,
@@ -1668,9 +1677,12 @@ server.tool("update_task", "Update a task's status or assignee. Status transitio
                 method: "PATCH",
                 body: JSON.stringify({
                     status,
-                    assignee: status === "assigned" && !assignee ? identity.actor_label : assignee,
+                    assignee: nextAssignee,
+                    assignee_agent_key: nextAssigneeAgentKey,
                     pr_url,
                     workflow_artifacts,
+                    actor_label: identity.actor_label,
+                    actor_key: identity.canonical_key,
                 }),
             },
         });
@@ -1706,7 +1718,7 @@ server.tool("complete_task", "Submit a task for review. Moves the task to 'in_re
     pr_url: z.string().optional().describe("GitHub PR URL for the work"),
     room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
     conversation_id: z.string().optional().describe("Optional conversation ID for per-conversation identity scoping."),
-}, async ({ task_id, pr_url, room_id, conversation_id: _conversationId }) => {
+}, async ({ task_id, pr_url, room_id, conversation_id }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
     if (!targetRoomId && !targetProjectId) {
@@ -1715,6 +1727,7 @@ server.tool("complete_task", "Submit a task for review. Moves the task to 'in_re
         };
     }
     try {
+        const identity = getConversationIdentity(conversation_id) ?? await ensureAgentIdentity();
         const updated = await roomScopedApiCall({
             room_id: targetRoomId,
             project_id: targetProjectId,
@@ -1722,11 +1735,27 @@ server.tool("complete_task", "Submit a task for review. Moves the task to 'in_re
             project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`,
             options: {
                 method: "PATCH",
-                body: JSON.stringify({ status: "in_review", pr_url }),
+                body: JSON.stringify({
+                    status: "in_review",
+                    pr_url,
+                    actor_label: identity.actor_label,
+                    actor_key: identity.canonical_key,
+                }),
             },
         });
+        await syncRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity, {
+            status: "reviewing",
+            status_text: `${task_id} -> in_review`,
+        });
         return {
-            content: [{ type: "text", text: JSON.stringify({ success: true, task: updated }, null, 2) }],
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        task: updated,
+                        agent_identity: toPublicAgentIdentity(identity),
+                    }, null, 2),
+                }],
         };
     }
     catch (error) {
@@ -1880,7 +1909,7 @@ server.tool("initialize_repo", "Initialize the current repo for Let Agents Chat
     }
 });
 // -- send_message -----------------------------------------------------------
-server.tool("send_message", "Send a message to a Let Agents Chat room.", {
+server.tool("send_message", "Send a message to a Let Agents Chat room. Use a short nudge (e.g. continue the plan) if another participant stopped after a closing message — silence does not always mean work is finished.", {
     room_id: z.string().optional().describe("Canonical room ID. Defaults to the current room."),
     sender: z
         .string()
@@ -1927,7 +1956,7 @@ server.tool("send_message", "Send a message to a Let Agents Chat room.", {
     };
 });
 // -- read_messages ----------------------------------------------------------
-server.tool("read_messages", "Read all messages from a Let Agents Chat room.", {
+server.tool("read_messages", "Read all messages from a Let Agents Chat room. For long-running work, prefer wait_for_messages with after_message_id so you only process new lines and do not treat an empty poll as the end of the mission.", {
     room_id: z.string().optional().describe("Canonical room ID. Defaults to the current room."),
 }, async ({ room_id }) => {
     const targetRoomId = getTargetRoomId(room_id);
@@ -1973,9 +2002,8 @@ server.tool("read_messages", "Read all messages from a Let Agents Chat room.", {
     };
 });
 // -- wait_for_messages ------------------------------------------------------
-const MAX_POLL_TIMEOUT_MS = 180000; // 3 minutes
 const DEFAULT_POLL_TIMEOUT_MS = 30000; // 30 seconds
-server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat room. Blocks until new messages arrive or 30 seconds elapse. Use the after_message_id parameter to only receive messages newer than a specific message.", {
+server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat room (HTTP long-poll). For multi-hour runs, call in a loop: always pass after_message_id from the last message you processed so an empty result means 'nothing new yet', not 'stop working'. If someone posted a premature 'I will wait' closing line, use send_message with a brief continue instruction. Per-call wait is capped (default max 180s unless LETAGENTS_POLL_MAX_MS is set on API and MCP).", {
     room_id: z.string().optional().describe("Canonical room ID. Defaults to the current room."),
     after_message_id: z
         .string()
@@ -1984,14 +2012,15 @@ server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat roo
     timeout: z
         .number()
         .optional()
-        .describe("Maximum wait time in milliseconds. If set to 0, the default timeout will be used."),
+        .describe("Maximum wait time in milliseconds (min 1000, capped by LETAGENTS_POLL_MAX_MS / server). If set to 0, the default timeout will be used."),
 }, async ({ room_id, after_message_id, timeout }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
     const identity = await ensureAgentIdentity();
     await heartbeatRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity);
-    const serverTimeout = Math.min(Math.max(timeout || DEFAULT_POLL_TIMEOUT_MS, 1000), MAX_POLL_TIMEOUT_MS);
-    const clientTimeout = serverTimeout + 5000; // 5s buffer over server timeout
+    const maxPollMs = getPollTimeoutCapMs();
+    const serverTimeout = Math.min(Math.max(timeout || DEFAULT_POLL_TIMEOUT_MS, 1000), maxPollMs);
+    const clientTimeout = serverTimeout + (serverTimeout > 120_000 ? 120_000 : 5_000);
     const params = new URLSearchParams();
     if (after_message_id)
         params.set("after", after_message_id);

package/dist/shared/poll-timeout-cap.js

@@ -0,0 +1,19 @@
+/**
+ * Upper bound for `GET .../messages/poll` wait duration and MCP `wait_for_messages` timeout.
+ *
+ * Default **180000** (3 minutes). Operators may raise it (e.g. **36000000** for 10 hours) by
+ * setting **`LETAGENTS_POLL_MAX_MS`** on both the API process and the MCP server process.
+ * Values are clamped to **24 hours** to avoid accidental runaway timers.
+ */
+export function getPollTimeoutCapMs() {
+    const raw = process.env.LETAGENTS_POLL_MAX_MS;
+    if (raw == null || raw === "") {
+        return 180_000;
+    }
+    const n = Number.parseInt(String(raw), 10);
+    if (Number.isNaN(n) || n < 1_000) {
+        return 180_000;
+    }
+    const ceiling = 86_400_000; // 24 hours
+    return Math.min(n, ceiling);
+}

package/dist/shared/room-participant.js

@@ -0,0 +1,20 @@
+import { parseAgentActorLabel } from "./agent-identity.js";
+export const ROOM_PARTICIPANT_KINDS = ["human", "agent"];
+function normalizeParticipantKeyPart(value) {
+    return String(value ?? "")
+        .trim()
+        .replace(/\s+/g, " ")
+        .toLowerCase();
+}
+export function buildAgentRoomParticipantKey(actorLabel) {
+    const normalizedActorLabel = normalizeParticipantKeyPart(parseAgentActorLabel(actorLabel)?.raw ?? actorLabel);
+    return normalizedActorLabel ? `agent:${normalizedActorLabel}` : null;
+}
+export function buildHumanRoomParticipantKey(input) {
+    const loginKey = normalizeParticipantKeyPart(input.github_login);
+    if (loginKey) {
+        return `human:login:${loginKey}`;
+    }
+    const displayNameKey = normalizeParticipantKeyPart(input.display_name);
+    return displayNameKey ? `human:name:${displayNameKey}` : null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.12.3",
+  "version": "0.12.4",
   "description": "Let Agents Chat — MCP server for AI agent communication",
   "type": "module",
   "main": "dist/mcp/server.js",
@@ -48,6 +48,7 @@
     "@types/pg": "^8.18.0",
     "drizzle-kit": "^0.31.10",
     "tsx": "^4.19.4",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "ws": "^8.20.0"
   }
 }

package/dist/mcp/__tests__/config-reader.test.js

@@ -1,93 +0,0 @@
-import { findLetagentsConfig, getRoomFromConfig } from "../config-reader";
-import { mkdirSync, writeFileSync, rmSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-// Helper to create temp directories with config files
-function createTempDir() {
-    const dir = join(tmpdir(), `letagents-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-function cleanup(dir) {
-    try {
-        rmSync(dir, { recursive: true, force: true });
-    }
-    catch {
-        // ignore cleanup errors
-    }
-}
-describe("findLetagentsConfig", () => {
-    let tempDir;
-    afterEach(() => {
-        if (tempDir)
-            cleanup(tempDir);
-    });
-    it("returns config when .letagents.json is in the start directory", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "github.com/EmmyMay/letagents" }));
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toEqual({ room: "github.com/EmmyMay/letagents" });
-    });
-    it("walks up to find config in parent directory", () => {
-        tempDir = createTempDir();
-        const childDir = join(tempDir, "src", "mcp");
-        mkdirSync(childDir, { recursive: true });
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "gitlab.com/team/project" }));
-        const config = findLetagentsConfig(childDir);
-        expect(config).toEqual({ room: "gitlab.com/team/project" });
-    });
-    it("returns null when no config file exists", () => {
-        tempDir = createTempDir();
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toBeNull();
-    });
-    it("returns null for config with missing room field", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ version: "1.0" }));
-        // Suppress console.error for this test
-        const spy = jest.spyOn(console, "error").mockImplementation();
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toBeNull();
-        spy.mockRestore();
-    });
-    it("returns null for config with empty room field", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "" }));
-        const spy = jest.spyOn(console, "error").mockImplementation();
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toBeNull();
-        spy.mockRestore();
-    });
-    it("returns null for invalid JSON", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), "not valid json {{{");
-        const spy = jest.spyOn(console, "error").mockImplementation();
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toBeNull();
-        spy.mockRestore();
-    });
-    it("trims whitespace from room name", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "  github.com/EmmyMay/letagents  " }));
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toEqual({ room: "github.com/EmmyMay/letagents" });
-    });
-});
-describe("getRoomFromConfig", () => {
-    let tempDir;
-    afterEach(() => {
-        if (tempDir)
-            cleanup(tempDir);
-    });
-    it("returns room string when config exists", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "github.com/EmmyMay/letagents" }));
-        const room = getRoomFromConfig(tempDir);
-        expect(room).toBe("github.com/EmmyMay/letagents");
-    });
-    it("returns null when no config exists", () => {
-        tempDir = createTempDir();
-        const room = getRoomFromConfig(tempDir);
-        expect(room).toBeNull();
-    });
-});

package/dist/mcp/__tests__/git-remote.test.js

@@ -1,37 +0,0 @@
-import { normalizeGitRemote } from "../git-remote";
-describe("normalizeGitRemote", () => {
-    // SSH format tests
-    it("normalizes SSH git@github.com format", () => {
-        expect(normalizeGitRemote("git@github.com:EmmyMay/letagents.git")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("normalizes SSH without .git suffix", () => {
-        expect(normalizeGitRemote("git@github.com:EmmyMay/letagents")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("normalizes SSH with gitlab host", () => {
-        expect(normalizeGitRemote("git@gitlab.com:team/project.git")).toBe("gitlab.com/team/project");
-    });
-    // HTTPS format tests
-    it("normalizes HTTPS with .git suffix", () => {
-        expect(normalizeGitRemote("https://github.com/EmmyMay/letagents.git")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("normalizes HTTPS without .git suffix", () => {
-        expect(normalizeGitRemote("https://github.com/EmmyMay/letagents")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("normalizes HTTPS with trailing slash", () => {
-        expect(normalizeGitRemote("https://github.com/EmmyMay/letagents/")).toBe("github.com/EmmyMay/letagents");
-    });
-    // SSH protocol format tests
-    it("normalizes ssh:// protocol format", () => {
-        expect(normalizeGitRemote("ssh://git@gitlab.com/team/project.git")).toBe("gitlab.com/team/project");
-    });
-    // Edge cases
-    it("handles whitespace", () => {
-        expect(normalizeGitRemote("  git@github.com:EmmyMay/letagents.git  ")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("handles nested paths", () => {
-        expect(normalizeGitRemote("https://gitlab.com/org/sub-group/project.git")).toBe("gitlab.com/org/sub-group/project");
-    });
-    it("handles Bitbucket SSH format", () => {
-        expect(normalizeGitRemote("git@bitbucket.org:workspace/repo.git")).toBe("bitbucket.org/workspace/repo");
-    });
-});

package/dist/mcp/__tests__/server-helpers.test.js

@@ -1,121 +0,0 @@
-/**
- * Tests for server helper functions:
- * - resolveGitRoot: resolves the root of a git repo from any subdirectory
- * - findExistingConfig: walks parent dirs to find .letagents.json
- *
- * These helpers underpin the corrected initialize_repo tool behavior.
- * @author Kingdavid Ehindero <kdof64squares@gmail.com>
- */
-import { execSync } from "child_process";
-import { existsSync, mkdirSync, writeFileSync, rmSync } from "fs";
-import { join, resolve } from "path";
-import { tmpdir } from "os";
-// ---------------------------------------------------------------------------
-// Re-implement helpers here (they are not exported from server.ts yet)
-// We test the logic directly until we extract them to a shared module.
-// ---------------------------------------------------------------------------
-function resolveGitRoot(dir) {
-    try {
-        const root = execSync("git rev-parse --show-toplevel", {
-            cwd: dir,
-            stdio: ["pipe", "pipe", "pipe"],
-            encoding: "utf-8",
-        }).trim();
-        return root || null;
-    }
-    catch {
-        return null;
-    }
-}
-function findExistingConfig(startDir) {
-    const { dirname } = require("path");
-    let current = startDir;
-    while (true) {
-        if (existsSync(join(current, ".letagents.json")))
-            return current;
-        const parent = dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    return null;
-}
-// ---------------------------------------------------------------------------
-// Helpers for tests
-// ---------------------------------------------------------------------------
-function makeTempGitRepo() {
-    const dir = join(tmpdir(), `letagents-test-${Date.now()}`);
-    mkdirSync(dir, { recursive: true });
-    execSync("git init", { cwd: dir, stdio: "pipe" });
-    execSync("git commit --allow-empty -m init", { cwd: dir, stdio: "pipe" });
-    return dir;
-}
-function cleanup(dir) {
-    try {
-        rmSync(dir, { recursive: true, force: true });
-    }
-    catch { /* ignore */ }
-}
-// ---------------------------------------------------------------------------
-// resolveGitRoot tests
-// ---------------------------------------------------------------------------
-describe("resolveGitRoot", () => {
-    let repoDir;
-    beforeAll(() => { repoDir = makeTempGitRepo(); });
-    afterAll(() => cleanup(repoDir));
-    it("returns the repo root when called from repo root", () => {
-        const result = resolveGitRoot(repoDir);
-        expect(result).toBe(resolve(repoDir));
-    });
-    it("returns the repo root when called from a subdirectory", () => {
-        const subDir = join(repoDir, "src", "deep", "path");
-        mkdirSync(subDir, { recursive: true });
-        const result = resolveGitRoot(subDir);
-        expect(result).toBe(resolve(repoDir));
-    });
-    it("returns null when not inside a git repo", () => {
-        const nonRepoDir = join(tmpdir(), `no-git-${Date.now()}`);
-        mkdirSync(nonRepoDir, { recursive: true });
-        const result = resolveGitRoot(nonRepoDir);
-        cleanup(nonRepoDir);
-        expect(result).toBeNull();
-    });
-    it("returns null for a non-existent directory", () => {
-        const result = resolveGitRoot(join(tmpdir(), "does-not-exist-12345"));
-        expect(result).toBeNull();
-    });
-});
-// ---------------------------------------------------------------------------
-// findExistingConfig tests
-// ---------------------------------------------------------------------------
-describe("findExistingConfig", () => {
-    let tempDir;
-    beforeEach(() => {
-        tempDir = join(tmpdir(), `letagents-cfg-test-${Date.now()}`);
-        mkdirSync(tempDir, { recursive: true });
-    });
-    afterEach(() => cleanup(tempDir));
-    it("returns null when no .letagents.json exists anywhere", () => {
-        const subDir = join(tempDir, "a", "b", "c");
-        mkdirSync(subDir, { recursive: true });
-        expect(findExistingConfig(subDir)).toBeNull();
-    });
-    it("finds config in the start directory", () => {
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "test" }));
-        expect(findExistingConfig(tempDir)).toBe(tempDir);
-    });
-    it("finds config in a parent directory when called from subdirectory", () => {
-        const subDir = join(tempDir, "nested", "path");
-        mkdirSync(subDir, { recursive: true });
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "test" }));
-        expect(findExistingConfig(subDir)).toBe(tempDir);
-    });
-    it("returns the closest config when multiple exist in the tree", () => {
-        const subDir = join(tempDir, "nested");
-        mkdirSync(subDir, { recursive: true });
-        // Config at root and at nested level — should find nested first
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "root" }));
-        writeFileSync(join(subDir, ".letagents.json"), JSON.stringify({ room: "nested" }));
-        expect(findExistingConfig(subDir)).toBe(subDir);
-    });
-});