@letta-ai/letta-code 0.31.11 → 0.31.13

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.31.11",
+  "version": "0.31.13",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
-  "packageManager": "bun@1.3.10",
+  "packageManager": "bun@1.3.14",
   "bin": {
     "letta": "letta.js"
   },
@@ -122,6 +122,7 @@
   },
   "license": "Apache-2.0",
   "engines": {
+    "bun": ">=1.3.2",
     "node": ">=22.19.0"
   },
   "publishConfig": {

package/scripts/codex-watch/release-analysis.test.ts

@@ -1,5 +1,6 @@
 import {
   findLatestStableReleaseAfter,
+  listStableReleases,
   type Release,
   releaseNotesForRange,
 } from "./release-analysis.ts";
@@ -49,3 +50,89 @@ describe("Codex stable release range", () => {
     );
   });
 });
+
+describe("Codex GitHub release fetch", () => {
+  test("retries a server error before succeeding", async () => {
+    const sleeps: number[] = [];
+    let requests = 0;
+
+    const releases = await listStableReleases({
+      fetchImpl: (async () => {
+        requests++;
+        if (requests === 1) {
+          return new Response("Gateway Timeout", { status: 504 });
+        }
+        return new Response(JSON.stringify(STABLES), { status: 200 });
+      }) as typeof fetch,
+      sleep: async (delayMs) => {
+        sleeps.push(delayMs);
+      },
+    });
+
+    expect(requests).toBe(2);
+    expect(sleeps).toEqual([1000]);
+    expect(releases).toEqual(STABLES);
+  });
+
+  test("retries a network error before succeeding", async () => {
+    const sleeps: number[] = [];
+    let requests = 0;
+
+    const releases = await listStableReleases({
+      fetchImpl: (async () => {
+        requests++;
+        if (requests === 1) throw new TypeError("fetch failed: ECONNRESET");
+        return new Response(JSON.stringify(STABLES), { status: 200 });
+      }) as typeof fetch,
+      sleep: async (delayMs) => {
+        sleeps.push(delayMs);
+      },
+    });
+
+    expect(requests).toBe(2);
+    expect(sleeps).toEqual([1000]);
+    expect(releases).toEqual(STABLES);
+  });
+
+  test("stops after the bounded retry budget", async () => {
+    const sleeps: number[] = [];
+    let requests = 0;
+
+    const result = listStableReleases({
+      fetchImpl: (async () => {
+        requests++;
+        return new Response("Gateway Timeout", { status: 504 });
+      }) as typeof fetch,
+      sleep: async (delayMs) => {
+        sleeps.push(delayMs);
+      },
+    });
+
+    await expect(result).rejects.toThrow(
+      "GitHub releases API failed (504): Gateway Timeout",
+    );
+    expect(requests).toBe(3);
+    expect(sleeps).toEqual([1000, 2000]);
+  });
+
+  test("fails immediately on a client error", async () => {
+    const sleeps: number[] = [];
+    let requests = 0;
+
+    const result = listStableReleases({
+      fetchImpl: (async () => {
+        requests++;
+        return new Response("Not Found", { status: 404 });
+      }) as typeof fetch,
+      sleep: async (delayMs) => {
+        sleeps.push(delayMs);
+      },
+    });
+
+    await expect(result).rejects.toThrow(
+      "GitHub releases API failed (404): Not Found",
+    );
+    expect(requests).toBe(1);
+    expect(sleeps).toEqual([]);
+  });
+});

package/scripts/codex-watch/release-analysis.ts

@@ -21,6 +21,8 @@ export const WATCHED_PATHS = [
 ];
 
 const MAX_COMMITS_PER_PATH = 8;
+const GITHUB_RELEASES_FETCH_ATTEMPTS = 3;
+const GITHUB_RELEASES_RETRY_DELAY_MS = 1_000;
 
 export interface Release {
   tag_name: string;
@@ -167,7 +169,12 @@ export async function analyzeCodexRelease(
   }
 }
 
-export async function listStableReleases(): Promise<Release[]> {
+export async function listStableReleases(
+  options: {
+    fetchImpl?: typeof fetch;
+    sleep?: (delayMs: number) => Promise<void>;
+  } = {},
+): Promise<Release[]> {
   const releases: Release[] = [];
   const headers: Record<string, string> = {
     Accept: "application/vnd.github+json",
@@ -175,15 +182,15 @@ export async function listStableReleases(): Promise<Release[]> {
   };
   const token = process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
   if (token) headers.Authorization = `Bearer ${token}`;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const sleep =
+    options.sleep ??
+    ((delayMs: number) =>
+      new Promise<void>((resolve) => setTimeout(resolve, delayMs)));
 
   for (let page = 1; page <= 10; page++) {
     const url = `https://api.github.com/repos/${CODEX_REPO}/releases?per_page=100&page=${page}`;
-    const res = await fetch(url, { headers });
-    if (!res.ok) {
-      throw new Error(
-        `GitHub releases API failed (${res.status}): ${await res.text()}`,
-      );
-    }
+    const res = await fetchGitHubReleasesPage(url, headers, fetchImpl, sleep);
     const batch = (await res.json()) as Release[];
     releases.push(...batch);
     if (batch.length < 100) break;
@@ -193,6 +200,49 @@ export async function listStableReleases(): Promise<Release[]> {
     .sort((a, b) => (a.published_at ?? "").localeCompare(b.published_at ?? ""));
 }
 
+async function fetchGitHubReleasesPage(
+  url: string,
+  headers: Record<string, string>,
+  fetchImpl: typeof fetch,
+  sleep: (delayMs: number) => Promise<void>,
+): Promise<Response> {
+  for (let attempt = 1; ; attempt++) {
+    let response: Response;
+    try {
+      response = await fetchImpl(url, { headers });
+    } catch (error) {
+      if (attempt === GITHUB_RELEASES_FETCH_ATTEMPTS) {
+        throw new Error(
+          `GitHub releases API request failed after ${attempt} attempts: ${String(error)}`,
+          { cause: error },
+        );
+      }
+      await retryGitHubReleasesFetch(attempt, String(error), sleep);
+      continue;
+    }
+
+    if (response.ok) return response;
+
+    const message = `GitHub releases API failed (${response.status}): ${await response.text()}`;
+    if (response.status < 500 || attempt === GITHUB_RELEASES_FETCH_ATTEMPTS) {
+      throw new Error(message);
+    }
+    await retryGitHubReleasesFetch(attempt, message, sleep);
+  }
+}
+
+async function retryGitHubReleasesFetch(
+  attempt: number,
+  error: string,
+  sleep: (delayMs: number) => Promise<void>,
+): Promise<void> {
+  const delayMs = GITHUB_RELEASES_RETRY_DELAY_MS * 2 ** (attempt - 1);
+  console.warn(
+    `${error}; retrying GitHub releases request in ${delayMs}ms (${attempt}/${GITHUB_RELEASES_FETCH_ATTEMPTS})`,
+  );
+  await sleep(delayMs);
+}
+
 function isStableRelease(release: Release): boolean {
   if (release.draft || release.prerelease) return false;
   return /^(rust-v|v)?\d+\.\d+\.\d+$/.test(release.tag_name);

package/scripts/postinstall-patches.js

@@ -16,6 +16,20 @@ import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkgRoot = dirname(__dirname);
 const require = createRequire(import.meta.url);
+const packageJson = JSON.parse(
+  readFileSync(join(pkgRoot, "package.json"), "utf-8"),
+);
+const minimumBunVersion = packageJson.engines.bun.replace(/^>=/, "");
+
+function isBunVersionSupported(version) {
+  const current = version.split(".").map(Number);
+  const minimum = minimumBunVersion.split(".").map(Number);
+  for (let index = 0; index < minimum.length; index++) {
+    if ((current[index] ?? 0) > (minimum[index] ?? 0)) return true;
+    if ((current[index] ?? 0) < (minimum[index] ?? 0)) return false;
+  }
+  return true;
+}
 
 async function copyToResolved(srcRel, targetSpecifier) {
   const src = join(pkgRoot, srcRel);
@@ -100,7 +114,10 @@ await copyToResolved(
   "ink/build/hooks/use-input.js",
 );
 await copyToResolved("vendor/ink/build/devtools.js", "ink/build/devtools.js");
-await copyToResolved("vendor/ink/build/log-update.js", "ink/build/log-update.js");
+await copyToResolved(
+  "vendor/ink/build/log-update.js",
+  "ink/build/log-update.js",
+);
 await copyToResolved("vendor/ink/build/wrap-text.js", "ink/build/wrap-text.js");
 
 // ink-text-input (optional vendor with externalCursorOffset support)
@@ -111,24 +128,30 @@ await copyToResolved(
 
 console.log("[patch] Ink runtime patched");
 
-// On Unix with Bun available, use polyglot shebang to prefer Bun runtime.
+// On Unix with a supported Bun available, use a polyglot shebang to prefer it.
 // This enables Bun.secrets for secure keychain storage instead of fallback.
-// Windows always uses #!/usr/bin/env node (polyglot shebang breaks npm wrappers).
+// Windows and installs with an older Bun keep the Node shebang.
 if (process.platform !== "win32") {
   try {
-    execSync("bun --version", { stdio: "ignore" });
-    const lettaPath = join(pkgRoot, "letta.js");
-    if (existsSync(lettaPath)) {
-      let content = readFileSync(lettaPath, "utf-8");
-      if (content.startsWith("#!/usr/bin/env node")) {
-        content = content.replace(
-          "#!/usr/bin/env node",
-          `#!/bin/sh
+    const bunVersion = execSync("bun --version", { encoding: "utf-8" }).trim();
+    if (isBunVersionSupported(bunVersion)) {
+      const lettaPath = join(pkgRoot, "letta.js");
+      if (existsSync(lettaPath)) {
+        let content = readFileSync(lettaPath, "utf-8");
+        if (content.startsWith("#!/usr/bin/env node")) {
+          content = content.replace(
+            "#!/usr/bin/env node",
+            `#!/bin/sh
 ":" //#; exec /usr/bin/env sh -c 'command -v bun >/dev/null && exec bun "$0" "$@" || exec node "$0" "$@"' "$0" "$@"`,
-        );
-        writeFileSync(lettaPath, content);
-        console.log("[patch] Configured letta to prefer Bun runtime");
+          );
+          writeFileSync(lettaPath, content);
+          console.log("[patch] Configured letta to prefer Bun runtime");
+        }
       }
+    } else {
+      console.log(
+        `[patch] Bun ${bunVersion} is below ${minimumBunVersion}; keeping Node runtime`,
+      );
     }
   } catch {
     // Bun not available, keep node shebang

package/scripts/source-file-size-baseline.json

@@ -10,7 +10,7 @@
   "src/cli/app/use-approval-flow.ts": 1163,
   "src/cli/app/use-configuration-handlers.ts": 1421,
   "src/cli/app/use-conversation-loop.ts": 2912,
-  "src/cli/app/use-submit-handler.ts": 4075,
+  "src/cli/app/use-submit-handler.ts": 4074,
   "src/cli/components/AgentSelector.tsx": 1104,
   "src/cli/components/InputRich.tsx": 2225,
   "src/cli/components/ModelSelector.tsx": 1259,
@@ -21,7 +21,7 @@
   "src/cli/mods/local-mod-loader.test.ts": 1043,
   "src/cli/reflection-transcript.test.ts": 1084,
   "src/cli/subcommands/skills.ts": 1264,
-  "src/headless.ts": 4994,
+  "src/headless.ts": 4986,
   "src/hooks/integration.test.ts": 1147,
   "src/index.ts": 2773,
   "src/mods/learning-harness.ts": 2434,
@@ -44,6 +44,6 @@
   "src/websocket/listener/file-commands.ts": 1053,
   "src/websocket/listener/lifecycle.ts": 1048,
   "src/websocket/listener/protocol-inbound.ts": 2207,
-  "src/websocket/listener/protocol-outbound.ts": 1047,
+  "src/websocket/listener/protocol-outbound.ts": 1042,
   "src/websocket/listener/turn.ts": 1058
 }

package/skills/browser-use/SKILL.md

@@ -19,66 +19,30 @@ Protocol reference: https://chromedevtools.github.io/devtools-protocol/.
 The running browser's exact schema is at `http://127.0.0.1:<port>/json/protocol`;
 tip-of-tree docs can differ from the installed version.
 
-## Managed cloud sandbox default: visible browser
-
-When running in a cloud sandbox, default every browser task to the visible
-managed desktop, even when the user did not explicitly ask to watch. Most
-browser tasks exist because plain HTTP is not enough; a headless browser is
-more likely to trigger bot protection and gives the user no way to observe or
-take over. This matters especially for clicking or typing, forms, sign-in,
-checkout/payment, CAPTCHAs or bot protection, and user handoff.
-
-For the first managed-sandbox browser window, use the skill's launcher instead
-of assembling Chrome, DISPLAY, or Xvfb commands yourself:
-
-```bash
-/root/.letta/cloud-skills/browser-use/scripts/open-visible-browser.sh 'https://example.com'
-```
-
-It starts the managed desktop and launches Chrome through the persistent Cua
-Driver with its required root flag. Then load `computer-use` for visible
-interaction. If protocol-level control is necessary, use Cua Driver's explicit
-`browser_prepare` flow after binding the exact visible window; do not pass
-remote-debugging flags through `launch_app`. The launcher exits zero only
-after Cua Driver reports an on-screen browser window. If it exits nonzero, stop
-and report the launch failure instead of claiming the browser opened.
+## Visible by default when a display exists
+
+When the computer has a display, prefer a visible (headful) browser for any
+task the user might watch or take over: clicking or typing, forms, sign-in,
+checkout/payment, CAPTCHAs or bot protection, and user handoff. Most browser
+tasks exist because plain HTTP is not enough; a headless browser is more
+likely to trigger bot protection and gives the user no way to observe or step
+in. Visible does not mean pixel-driven: keep operating the page over CDP, and
+the user sees every action in the window.
+
+Use headless mode only for work the user explicitly wants in the background
+and that cannot require interaction or handoff, such as read-only scraping,
+CI, or screenshot/PDF generation, or when no display exists. A headless page
+does not satisfy a request to open or reopen a site in a browser the user can
+see.
 
 When the user asks to review, watch, or take over, leave that browser window
 open after the task. Do not kill or close it before replying.
 
-1. Run `start-letta-desktop` and use its exit status as the result. Warnings
-   from optional services do not mean startup failed when the command exits 0.
-   If it exits nonzero, stop and report that the managed desktop is
-   unavailable. Never create another Xvfb, VNC server, or private display: the
-   Computer viewer only shows the managed desktop.
-2. Load `computer-use`, inspect the managed desktop, and use Cua Driver to
-   operate an existing Chrome window or launch Chrome there. When launching,
-   round-trip Chrome's `launch_path` from `cua-driver call list_apps '{}'
-   instead of rebuilding it; the managed launch path carries required flags.
-   For forms, sign-in, checkout, CAPTCHA, and bot-protected pages, keep using
-   Cua Driver so the interaction remains visible and available for user
-   takeover.
-3. Use CDP only when protocol-level inspection or deterministic automation is
-   needed. Bind the exact visible browser window with Cua Driver, then use its
-   explicit `browser_prepare` flow. Do not pass remote-debugging flags
-   through `launch_app`. Include `--no-sandbox` when running Chrome as
-   root. Do not add `--headless` or override `DISPLAY`.
-4. Use headless mode only for work the user explicitly wants in the background
-   and that cannot require interaction or handoff, such as read-only scraping,
-   CI, or screenshot/PDF generation.
-5. Verify the result through the managed desktop window (Cua Driver window
-   state or screenshot), not only through DOM output or a screenshot from a
-   separate process.
-
-A headless page does not satisfy a request to open or reopen a site in the
-user-visible browser.
-
 ## Workflow
 
 1. Find a Chromium-based browser (below). If none exists, see "No Chrome installed".
-2. In a managed cloud sandbox, follow the visible-browser default above.
-   Otherwise, launch with a dedicated profile and remote debugging. Never
-   attach to the user's normal profile unless explicitly asked.
+2. Launch with a dedicated profile and remote debugging. Never attach to the
+   user's normal profile unless explicitly asked.
 3. Discover targets via `/json/list`; pick the `"page"` target by URL or title.
 4. Connect to its `webSocketDebuggerUrl` and enable only the domains you need
    (usually `Page`, `Runtime`, `DOM`, `Input`; add `Network`, `Log` when debugging).
@@ -124,7 +88,7 @@ Tell the user that browser use requires Chrome or another Chromium-based
 browser and recommend either:
 
 1. Install Chrome on the current computer, then retry the browser task.
-2. Teleport the conversation back to its Cloud sandbox, where the managed
+2. Teleport the conversation back to its Cloud sandbox, where a
    browser is already installed.
 
 Wait for the user to choose. Do not silently replace the browser task with
@@ -132,9 +96,8 @@ plain HTTP or claim browser automation succeeded.
 
 ## Launching
 
-Outside a managed cloud sandbox, use a disposable profile and a fixed port.
-Chrome refuses to run as root without `--no-sandbox`, so add that flag when
-`id -u` is 0:
+Use a disposable profile and a fixed port. Chrome refuses to run as root
+without `--no-sandbox`, so add that flag when `id -u` is 0:
 
 ```bash
 chrome_args=( \
@@ -149,10 +112,8 @@ chrome_args=( \
 "$CHROME" "${chrome_args[@]}" https://example.com
 ```
 
-Outside a managed cloud sandbox, add `--headless=new` only for explicitly
-invisible work or when no display exists. In a managed cloud sandbox, follow
-the visible-browser rule above and never replace its managed display with a
-private one.
+Add `--headless=new` only for explicitly invisible work or when no display
+exists (see "Visible by default" above).
 With `--remote-debugging-port=0`, read the chosen port from
 `<user-data-dir>/DevToolsActivePort`. Launch in the background and poll
 `http://127.0.0.1:9222/json/version` until it responds.

package/skills/dispatching-coding-agents/SKILL.md

@@ -66,7 +66,7 @@ Different agents have different strengths. Track what works in your memory over
 - Use `--max-budget-usd N` (Claude Code) to cap spend on exploratory tasks
 
 ### Known quirks
-- **Claude Code can hang on large repos** with unrestricted tools — consider `--allowedTools "Read Grep Glob"` (no Bash) and shorter timeouts for research tasks
+- **Claude Code can hang on large repos** with unrestricted tools — consider `--tools "Read Grep Glob"` (no Bash) and shorter timeouts for research tasks
 - **Codex compactions can destroy long trajectories** — for very long tasks, prefer multiple shorter sessions over one marathon
 - **Opus tends to over-generate** — produces more code than necessary. Good for exploration, verify before applying.
 
@@ -135,7 +135,7 @@ cd /path/to/repo && claude -p "Read /tmp/my-plan.md and critique it. What am I m
 
 ## Handling Failures
 
-- **Timeout**: If an agent times out (especially Claude Code on large repos), try: (1) a shorter, more focused prompt, (2) restricting tools with `--allowedTools`, (3) switching to Codex which handles large repos better
+- **Timeout**: If an agent times out (especially Claude Code on large repos), try: (1) a shorter, more focused prompt, (2) restricting tools with `--tools`, (3) switching to Codex which handles large repos better
 - **Garbage output**: If results are incoherent, the prompt was probably too vague. Rewrite with more specific file paths and clearer instructions.
 - **Session errors**: Claude Code can hit "stale approval from interrupted session" — `--dangerously-skip-permissions` prevents this. If Codex errors, start a fresh `exec` session.
 - **Compaction mid-task**: If a Codex session runs long enough to compact, it may lose earlier context. Break long tasks into smaller sequential sessions.
@@ -153,12 +153,13 @@ claude -p "YOUR PROMPT" --model MODEL --dangerously-skip-permissions
 | `-p` / `--print` | Non-interactive mode, prints response and exits |
 | `--dangerously-skip-permissions` | Skip approval prompts (prevents stale approval errors on timeout) |
 | `--model MODEL` | Alias or model name accepted by the installed CLI; omit to use the configured default |
-| `--effort LEVEL` | `low`, `medium`, `high` — controls reasoning depth |
+| `--effort LEVEL` | `low`, `medium`, `high`, `xhigh`, `max` — controls reasoning depth |
 | `--append-system-prompt "..."` | Inject additional system instructions |
-| `--allowedTools "Bash Edit Read"` | Restrict available tools |
+| `--allowedTools "Bash Edit Read"` | Tools that execute without prompting for permission |
+| `--tools "Read Grep Glob"` | Restrict which built-in tools are available |
 | `--max-budget-usd N` | Cap spend for the invocation |
 | `--add-dir DIR` | Allow access to an additional directory; does not change the working directory |
-| `--output-format json` | Structured output with `session_id`, `cost_usd`, `duration_ms` |
+| `--output-format json` | Structured output with `session_id`, `total_cost_usd`, `duration_ms` |
 
 Set Claude Code's working directory with `cd /path/to/repo && claude ...` in the Bash command, not with a Claude flag.
 
@@ -174,7 +175,6 @@ codex exec "YOUR PROMPT" --sandbox workspace-write
 | `-m MODEL` | Model accepted by the installed CLI; omit to use the configured default |
 | `--sandbox MODE` | Select a read-only or writable sandbox |
 | `-C DIR` | Set working directory |
-| `--search` | Enable web search tool |
 | `review` | Native code review — `codex review --uncommitted` or `codex exec review "prompt"` |
 
 ## Session Management

package/skills/messaging-agents/SKILL.md

@@ -66,15 +66,24 @@ Results include `agent_id` for each matching message.
 letta -p --from-agent $LETTA_AGENT_ID --agent <id> "message text"
 ```
 
-When no `--environment` is specified, the target agent will run in the same
-environment as the caller agent.
+When no `--computer` is specified, the target agent will run on the same
+computer as the caller agent.
 
-To route the target agent turn through a specific remote/local environment:
+To route the target agent turn through a specific remote/local computer:
 
 ```bash
 letta -p --from-agent $LETTA_AGENT_ID \
   --agent <id> \
-  --environment <name-or-device-id-or-connection-id> \
+  --computer <name-or-device-id-or-connection-id> \
+  "message text"
+```
+
+Use `--computer cloud` to route through the target agent's cloud sandbox:
+
+```bash
+letta -p --from-agent $LETTA_AGENT_ID \
+  --agent <id> \
+  --computer cloud \
   "message text"
 ```
 
@@ -83,7 +92,7 @@ letta -p --from-agent $LETTA_AGENT_ID \
 |-----|----------|-------------|
 | `--agent <id>` | Yes | Target agent ID to message |
 | `--from-agent <id>` | Yes | Sender agent ID (injects agent-to-agent system reminder) |
-| `--environment <selector>` | No | Route through an online environment by connection name, device ID, or connection ID |
+| `--computer <selector>` | No | Route through `cloud` (target agent's cloud sandbox) or an online computer by connection name, device ID, or connection ID |
 | `"message text"` | Yes | Message body (positional after flags) |
 
 **Example:**
@@ -93,13 +102,17 @@ letta -p --from-agent $LETTA_AGENT_ID \
   "What do you know about the authentication system?"
 ```
 
-**Response:**
+**Response (JSON format with `--output json`):**
 ```json
 {
-  "conversation_id": "conversation-xyz789",
-  "response": "The authentication system uses JWT tokens...",
+  "type": "result",
+  "subtype": "success",
+  "is_error": false,
+  "result": "The authentication system uses JWT tokens...",
   "agent_id": "agent-abc123",
-  "agent_name": "BackendExpert"
+  "conversation_id": "conversation-xyz789",
+  "environment": { "source": "same-environment" },
+  "usage": { "prompt_tokens": 120, "completion_tokens": 80, "total_tokens": 200, "step_count": 1 }
 }
 ```
 
@@ -109,34 +122,34 @@ letta -p --from-agent $LETTA_AGENT_ID \
 letta -p --from-agent $LETTA_AGENT_ID --conversation <id> "message text"
 ```
 
-Add `--environment <selector>` to continue the conversation on a specific environment.
+Add `--computer <selector>` to continue the conversation on a specific computer.
 
-### Discovering Environments
+### Discovering Computers
 
 ```bash
-letta environments list --online-only
+letta computers list --online-only
 # alias:
 letta envs list --online-only
 ```
 
 Use `connectionName`, `deviceId`, or `connectionId` from the JSON output as the
-`--environment` selector. If a name is ambiguous, prefer `deviceId` or
-`connectionId`. In `environments list`, the current local runtime is marked with
+`--computer` selector. If a name is ambiguous, prefer `deviceId` or
+`connectionId`. In `computers list`, the current local runtime is marked with
 `"isCurrent": true`.
 
-To force the target agent onto the current registered Letta Code environment,
-resolve the current environment and pass its `connectionId`:
+To force the target agent onto the current registered Letta Code computer,
+resolve the current computer and pass its `connectionId`:
 
 ```bash
-CURRENT_ENV=$(letta environments current | jq -r .connectionId)
+CURRENT_COMPUTER=$(letta computers current | jq -r .connectionId)
 letta -p --from-agent $LETTA_AGENT_ID \
   --agent agent-abc123 \
-  --environment "$CURRENT_ENV" \
-  "Run on my same machine/environment."
+  --computer "$CURRENT_COMPUTER" \
+  "Run on my same computer."
 ```
 
-Omit `--environment` when you want the target agent to run in the same
-environment as the caller agent.
+Omit `--computer` when you want the target agent to run on the same computer as
+the caller agent.
 
 **Arguments:**
 | Arg | Required | Description |

package/skills/scheduling-tasks/SKILL.md

@@ -21,7 +21,7 @@ This skill lets you create, list, and manage scheduled tasks using the `letta cr
 Pass a flag only when you have a requirement the default can't infer:
 
 - **`--runner cloud`** — the schedule must fire no matter which computers are online; execute in the agent's cloud sandbox.
-- **`--computer <deviceId>`** — the work needs a specific connected computer (its filesystem, services, or credentials). Get the deviceId from `letta environments list`. If that computer is offline at fire time, execution falls back to the cloud sandbox.
+- **`--computer <deviceId>`** — the work needs a specific connected computer (its filesystem, services, or credentials). Get the deviceId from `letta computers list`. If that computer is offline at fire time, execution falls back to the cloud sandbox.
 - **`--runner local`** — the work must only ever run on the current computer, even if that means missing fires while no session is running here.
 
 The CLI reports its placement in the command output. If it warns that the schedule is local (this happens when the cloud scheduler cannot reach the current computer), the schedule only fires while a Letta session is running here — read the warning and decide whether that's acceptable.

package/skills/submitting-feedback/SKILL.md

@@ -1,11 +1,13 @@
 ---
 name: submitting-feedback
-description: Submits user-approved feedback about Letta Code or the current agent to the Letta team. Load when the user is upset, frustrated, dissatisfied, reports poor agent behavior, or asks to send feedback. Works with cloud-hosted and local agents. Ask before submitting unless the user already explicitly requested submission.
+description: Submits user-approved product feedback and bug reports about Letta Code to the Letta team. Load when the user reports a Letta Code bug, requests a product or developer change, or explicitly asks to send feedback. Do not load for corrections to the current agent's behavior or preferences; those are memory edits. Works with cloud-hosted and local agents. Ask before submitting unless the user already explicitly requested submission.
 ---
 
 # Submitting Feedback
 
-When the user appears upset with the agent, acknowledge the problem and ask whether they want you to submit feedback to the Letta team. Do not submit merely because the user expressed frustration.
+Use this skill for product and developer feedback about Letta Code: reproducible bugs, broken features, confusing product behavior, and requested changes to the software or its developer-facing behavior.
+
+Do **not** use this skill when the user corrects how the current agent should behave, communicate, remember, or work with them. Treat that as learning: make the appropriate memory edit so the correction changes the agent's future behavior. A user's frustration with the agent is not by itself product feedback and is not a reason to offer feedback submission.
 
 If the user says yes, or directly asks you to submit feedback: