@letta-ai/letta-code 0.32.12 → 0.32.14

package/scripts/build-pypi.py

@@ -0,0 +1,172 @@
+"""Build a self-contained letta wheel on its target OS/CPU.
+
+Prerequisites: locked `bun install --frozen-lockfile`, Bun, npm, Python 3.9+,
+C/C++ toolchain (node-pty). Run from any directory; artifacts go to python/dist.
+Linux release builds MUST run in the manylinux_2_28 CI image, not a newer host.
+No upload/publish is performed by this script.
+"""
+
+import hashlib
+import importlib.util
+import json
+import os
+import platform
+import re
+import shutil
+import subprocess
+import tarfile
+import tempfile
+import urllib.request
+import zipfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+NODE = "22.19.0"
+# Official nodejs.org SHASUMS256.txt; pin the archive, not only the version.
+TARGETS = {
+    ("Linux", "x86_64"): (
+        "linux-x64",
+        "manylinux_2_28_x86_64",
+        "d36e56998220085782c0ca965f9d51b7726335aed2f5fc7321c6c0ad233aa96d",
+    ),
+    ("Linux", "aarch64"): (
+        "linux-arm64",
+        "manylinux_2_28_aarch64",
+        "d32817b937219b8f131a28546035183d79e7fd17a86e38ccb8772901a7cd9009",
+    ),
+    ("Darwin", "arm64"): (
+        "darwin-arm64",
+        "macosx_14_0_arm64",
+        "c59006db713c770d6ec63ae16cb3edc11f49ee093b5c415d667bb4f436c6526d",
+    ),
+    ("Darwin", "x86_64"): (
+        "darwin-x64",
+        "macosx_14_0_x86_64",
+        "3cfed4795cd97277559763c5f56e711852d2cc2420bda1cea30c8aa9ac77ce0c",
+    ),
+    ("Windows", "AMD64"): (
+        "win-x64",
+        "win_amd64",
+        "ea3fad0e67a991d8477d8c01344b56e69c676ccb733f065b22436994b1253f86",
+    ),
+}
+
+
+def run(args, **kwargs):
+    # npm.cmd requires a shell on Windows; all arguments here are build-owned.
+    if os.name == "nt" and args[0] in ("npm", "bun"):
+        args[0] += ".cmd" if args[0] == "npm" else ".exe"
+    return subprocess.check_output(args, cwd=ROOT, **kwargs)
+
+
+def main():
+    key = (platform.system(), platform.machine())
+    if key not in TARGETS:
+        raise SystemExit(f"Unsupported wheel platform: {key[0]} {key[1]}")
+    target, wheel_platform, checksum = TARGETS[key]
+    if platform.system() == "Linux" and platform.libc_ver()[0] != "glibc":
+        raise SystemExit("Only glibc Linux is supported (not musl/Alpine)")
+    # Do not falsely label artifacts built on a newer glibc as manylinux_2_28.
+    if platform.system() == "Linux" and platform.libc_ver()[1] != "2.28":
+        if os.environ.get("LETTA_PYPI_LOCAL_TEST") != "1":
+            raise SystemExit(
+                "Use the manylinux_2_28 CI image, or LETTA_PYPI_LOCAL_TEST=1 for a non-publishable local wheel"
+            )
+        wheel_platform = "linux_" + platform.machine()
+    version = json.loads((ROOT / "package.json").read_text())["version"]
+    if not re.fullmatch(r"\d+\.\d+\.\d+", version):
+        raise SystemExit("PyPI builds currently require a stable X.Y.Z package version")
+    payload = ROOT / "python/letta_code/_payload"
+    shutil.rmtree(payload, ignore_errors=True)
+    (payload / "bin").mkdir(parents=True)
+    app = payload / "app"
+    app.mkdir()
+    extension = "zip" if os.name == "nt" else "tar.gz"
+    archive_name = f"node-v{NODE}-{target}.{extension}"
+    with tempfile.TemporaryDirectory() as temporary:
+        archive = Path(temporary) / archive_name
+        urllib.request.urlretrieve(
+            f"https://nodejs.org/dist/v{NODE}/{archive_name}", archive
+        )
+        if hashlib.sha256(archive.read_bytes()).hexdigest() != checksum:
+            raise SystemExit("Node archive checksum mismatch")
+        prefix = f"node-v{NODE}-{target}"
+        # Extract only trusted, explicitly named runtime/license files, never npm.
+        names = {
+            "node.exe" if os.name == "nt" else "bin/node": "bin/node.exe"
+            if os.name == "nt"
+            else "bin/node",
+            "LICENSE": "NODE-LICENSE",
+        }
+        if extension == "zip":
+            with zipfile.ZipFile(archive) as source:
+                for member, destination in names.items():
+                    (payload / destination).write_bytes(
+                        source.read(f"{prefix}/{member}")
+                    )
+        else:
+            with tarfile.open(archive) as source:
+                for member, destination in names.items():
+                    (payload / destination).write_bytes(
+                        source.extractfile(f"{prefix}/{member}").read()
+                    )
+    node = payload / "bin" / ("node.exe" if os.name == "nt" else "node")
+    node.chmod(0o755)
+    env = os.environ.copy()
+    env["PATH"] = str(node.parent) + os.pathsep + env.get("PATH", "")
+    run(["bun", "run", "build"], env=env)
+    packed = json.loads(
+        run(["npm", "pack", "--dry-run", "--json", "--ignore-scripts"], env=env)
+    )
+    for entry in packed[0]["files"]:
+        path = entry["path"]
+        destination = app / path
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(ROOT / path, destination)
+    run([str(node), "scripts/stage-pypi-deps.mjs", str(app)], env=env)
+    # Native addons must be built with the Node ABI we ship, not Bun/host Node.
+    npm = shutil.which("npm")
+    native_env = env.copy()
+    native_env["npm_config_build_from_source"] = "true"
+    subprocess.run(
+        [npm, "rebuild", "node-pty", "--foreground-scripts"],
+        cwd=app,
+        env=native_env,
+        check=True,
+        shell=os.name == "nt",
+    )
+    subprocess.run(
+        [npm, "rebuild", "@vscode/ripgrep", "--foreground-scripts"],
+        cwd=app,
+        env=env,
+        check=True,
+        shell=os.name == "nt",
+    )
+    pty = app / "node_modules/node-pty"
+    shutil.rmtree(pty / "prebuilds", ignore_errors=True)
+    for path in ("third_party", "deps", "src", "build/Release/obj.target"):
+        shutil.rmtree(pty / path, ignore_errors=True)
+    for helper in app.rglob("spawn-helper"):
+        helper.chmod(0o755)
+    (payload / "manifest.json").write_text(
+        json.dumps(
+            {
+                "version": version,
+                "node": NODE,
+                "target": target,
+                "wheel_platform": wheel_platform,
+            },
+            indent=2,
+        )
+        + "\n"
+    )
+    spec = importlib.util.spec_from_file_location(
+        "wheel_backend", ROOT / "python/wheel_backend.py"
+    )
+    backend = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(backend)
+    print(backend.build_wheel(str(ROOT / "python/dist")))
+
+
+if __name__ == "__main__":
+    main()

package/scripts/isolated-unit-tests.json

@@ -1,5 +1,15 @@
 {
   "tests": [
+    {
+      "path": "src/tools/impl/task-fork-receipt.test.ts",
+      "timeoutMs": 15000,
+      "reason": "Replaces billing I/O and the child process while exercising real fork launch state and task receipts with process-global backend, settings, and subagent state."
+    },
+    {
+      "path": "src/tools/impl/task-computer-routing.test.ts",
+      "timeoutMs": 15000,
+      "reason": "Mocks subagent discovery and the child-process launch boundary while exercising task() with process-global backend and subagent state."
+    },
     {
       "path": "src/websocket/listener/turn-cleanup-shared-memory.e2e.test.ts",
       "timeoutMs": 30000,
@@ -71,6 +81,11 @@
       "timeoutMs": 15000,
       "reason": "Renders Ink while mutating the backend mode, backend instance, provider registry, settings singleton, and model cache."
     },
+    {
+      "path": "src/cli/app/use-configuration-handlers.test.tsx",
+      "timeoutMs": 15000,
+      "reason": "Renders the reasoning picker while replacing the shared runtime model catalog; shared batches can retain prior catalog or Ink state."
+    },
     {
       "path": "src/cli/message-search-cache-warm.test.ts",
       "timeoutMs": 15000,
@@ -180,11 +195,6 @@
       "timeoutMs": 15000,
       "reason": "Uses a top-level Bun module mock for the backend client."
     },
-    {
-      "path": "src/tools/toolset-memfs-detach.test.ts",
-      "timeoutMs": 15000,
-      "reason": "Uses a top-level Bun module mock for the backend client."
-    },
     {
       "path": "src/websocket/listen-client-concurrency.test.ts",
       "timeoutMs": 30000,

package/scripts/smoke-pypi.py

@@ -0,0 +1,236 @@
+"""Install and exercise a wheel offline, outside the checkout and without Node/npm on PATH."""
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import venv
+from pathlib import Path
+
+ARGUMENT_PROBE = r"""
+import assert from 'node:assert/strict';
+assert.equal(process.env.LETTA_CODE_DISTRIBUTION, 'pypi');
+assert.deepEqual(process.argv.slice(2), ['space argument', 'unicode-λ', '--literal=$HOME']);
+assert.ok(process.execPath.includes('_payload'));
+process.exit(23); // Verify the Python launcher preserves child exit status.
+"""
+
+RUNTIME_PROBE = r"""
+import {createRequire as bootstrapRequire} from 'node:module';
+const require = bootstrapRequire(import.meta.url);
+const assert = require('node:assert/strict');
+const {createRequire} = require('node:module');
+const {spawnSync} = require('node:child_process');
+const path = require('node:path');
+const fs = require('node:fs');
+const cli = process.argv[2];
+const app = path.dirname(cli);
+const req = createRequire(cli);
+const env = {...process.env};
+delete env.NODE_OPTIONS;
+assert.equal(process.env.LETTA_CODE_DISTRIBUTION, 'pypi');
+assert.ok(process.execPath.includes('_payload'));
+const child = spawnSync('node', ['-p', 'process.execPath'], {env, encoding:'utf8'});
+assert.equal(child.status, 0, child.stderr);
+assert.equal(fs.realpathSync(child.stdout.trim()), fs.realpathSync(process.execPath));
+if (process.platform !== 'win32') {
+  const direct = spawnSync(cli, ['--version'], {env, encoding:'utf8'});
+  assert.equal(direct.status, 0, direct.stderr); // Executable bits + /usr/bin/env node.
+  assert.match(direct.stdout, /Letta Code/);
+}
+assert.ok(fs.existsSync(path.join(app, 'skills', 'letta-guide', 'SKILL.md')));
+assert.ok(fs.existsSync(path.join(app, 'assets', 'tutor-profile.png')));
+const rg = spawnSync(req('@vscode/ripgrep').rgPath, ['--version'], {env, encoding:'utf8'});
+assert.equal(rg.status, 0, rg.stderr);
+assert.match(rg.stdout, /ripgrep/);
+assert.equal(typeof req('ws').WebSocketServer, 'function');
+(async () => {
+  const {Bot} = req('grammy');
+  const bot = new Bot('123:test');
+  bot.api.config.use(async () => ({ok:true, result:{id:123, is_bot:true, first_name:'wheel', username:'wheel_bot'}}));
+  await bot.init();
+  const svg = '<svg xmlns="http://www.w3.org/2000/svg" width="3000" height="2"><rect width="3000" height="2" fill="red"/></svg>';
+  const resized = spawnSync(process.execPath, [path.join(app, 'image-resize-worker.js'), 'image/svg+xml'], {input:svg, env});
+  assert.equal(resized.status, 0, resized.stderr.toString());
+  const image = JSON.parse(resized.stdout);
+  assert.ok(image.width > 0 && image.width < 3000, JSON.stringify(image));
+  const ptyCommand = process.platform === 'win32' ? process.env.ComSpec : process.execPath;
+  const ptyArgs = process.platform === 'win32' ? ['/d', '/s', '/c', 'echo LETTA_PTY_OK'] : [cli, '--help'];
+  const ptyExpected = process.platform === 'win32' ? /LETTA_PTY_OK/ : /USAGE/;
+  const pty = req('node-pty').spawn(ptyCommand, ptyArgs, {env, cols:100, rows:30});
+  let output = '';
+  pty.onData(data => { output += data; });
+  const timeout = setTimeout(() => { pty.kill(); throw new Error('PTY timed out'); }, 30000);
+  pty.onExit(({exitCode}) => {
+    clearTimeout(timeout);
+    assert.equal(exitCode, 0, output);
+    assert.match(output, ptyExpected);
+    console.log('native PTY, image worker, ripgrep, Telegram, assets and child Node passed');
+    process.exit(0);
+  });
+})().catch(error => {console.error(error); process.exit(1)});
+// Hold the script until the asynchronous probe exits.
+await new Promise(() => {});
+"""
+
+
+def main():
+    wheel = Path(sys.argv[1]).resolve()
+    if wheel.stat().st_size >= 100 * 1024 * 1024:
+        raise SystemExit("Wheel exceeds the default PyPI 100 MiB artifact limit")
+    with tempfile.TemporaryDirectory(prefix="letta wheel smoke ") as temporary:
+        root = Path(temporary)
+        environment = root / "venv"
+        venv.create(environment, with_pip=True)
+        binary = environment / ("Scripts" if os.name == "nt" else "bin")
+        python = binary / ("python.exe" if os.name == "nt" else "python")
+        cli = binary / ("letta.exe" if os.name == "nt" else "letta")
+        subprocess.run(
+            [
+                str(python),
+                "-m",
+                "pip",
+                "install",
+                "--no-index",
+                "--no-deps",
+                str(wheel),
+            ],
+            check=True,
+        )
+        home = root / "home"
+        home.mkdir()
+        env = {
+            k: v
+            for k, v in os.environ.items()
+            if not k.startswith(("LETTA", "NODE_", "NPM_"))
+            and k not in ("AGENT_ID", "CONVERSATION_ID", "MEMORY_DIR")
+        }
+        env.update(
+            HOME=str(home),
+            USERPROFILE=str(home),
+            PATH=str(binary),
+            DISABLE_AUTOUPDATER="0",
+        )
+        if os.name == "nt":
+            env["PATH"] += os.pathsep + str(Path(os.environ["SystemRoot"]) / "System32")
+        for args, expected, code in [
+            (["--help"], "USAGE", 0),
+            (["--version"], "Letta Code", 0),
+            (["update"], "uv tool upgrade letta", 1),
+        ]:
+            result = subprocess.run(
+                [str(cli), *args],
+                cwd=root,
+                env=env,
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=45,
+            )
+            assert result.returncode == code, (args, result.stdout, result.stderr)
+            assert expected in result.stdout + result.stderr, result
+        env.update(
+            LETTA_LOCAL_BACKEND_DIR=str(root / "local-store"),
+            LETTA_LOCAL_BACKEND_EXECUTOR="deterministic",
+            LETTA_SKIP_KEYCHAIN_CHECK="1",
+        )
+        result = subprocess.run(
+            [
+                str(cli),
+                "--backend",
+                "local",
+                "--ephemeral",
+                "-m",
+                "openai/gpt-5.6-luna",
+                "-p",
+                "wheel runtime smoke",
+                "--tools=",
+                "--output-format",
+                "json",
+            ],
+            cwd=root,
+            env=env,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        assert result.returncode == 0, (result.stdout, result.stderr)
+        response = json.loads(result.stdout)
+        assert response["conversation_id"].startswith("local-conv-"), response
+        assert response["result"], response
+        print("Installed headless deterministic local turn passed")
+        argument_probe = root / "argument-probe.mjs"
+        argument_probe.write_text(ARGUMENT_PROBE, encoding="utf-8")
+        env["NODE_OPTIONS"] = "--import=" + json.dumps(argument_probe.as_uri())
+        result = subprocess.run(
+            [str(cli), "space argument", "unicode-λ", "--literal=$HOME"],
+            cwd=root,
+            env=env,
+            check=False,
+            timeout=60,
+        )
+        assert result.returncode == 23, result
+        del env["NODE_OPTIONS"]
+        payload = Path(
+            subprocess.check_output(
+                [
+                    str(python),
+                    "-c",
+                    "from pathlib import Path; import letta_code; print(Path(letta_code.__file__).parent / '_payload')",
+                ],
+                text=True,
+            ).strip()
+        )
+        node = payload / "bin" / ("node.exe" if os.name == "nt" else "node")
+        installed_cli = payload / "app" / "letta.js"
+        runtime_probe = root / "runtime-probe.mjs"
+        runtime_probe.write_text(RUNTIME_PROBE, encoding="utf-8")
+        env["PATH"] = str(node.parent) + os.pathsep + env["PATH"]
+        env["LETTA_CODE_DISTRIBUTION"] = "pypi"
+        result = subprocess.run(
+            [str(node), str(runtime_probe), str(installed_cli)],
+            cwd=root,
+            env=env,
+            check=False,
+            timeout=60,
+        )
+        assert result.returncode == 0, result
+        if os.name != "nt":
+            import selectors
+            import signal
+
+            signal_probe = root / "signal.mjs"
+            signal_probe.write_text(
+                "process.on('SIGTERM', () => process.exit(42)); console.log(process.pid); setInterval(() => {}, 1000); await new Promise(() => {});"
+            )
+            env["NODE_OPTIONS"] = "--import=" + json.dumps(signal_probe.as_uri())
+            process = subprocess.Popen(
+                [str(cli)],
+                cwd=root,
+                env=env,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            try:
+                with selectors.DefaultSelector() as selector:
+                    selector.register(process.stdout, selectors.EVENT_READ)
+                    assert selector.select(timeout=15), "Signal probe did not start"
+                    assert int(process.stdout.readline()) == process.pid, (
+                        "Launcher did not exec Node"
+                    )
+                process.send_signal(signal.SIGTERM)
+                process.communicate(timeout=15)
+                assert process.returncode == 42, process.returncode
+            finally:
+                if process.poll() is None:
+                    process.kill()
+                    process.wait()
+            print("POSIX PID and SIGTERM forwarding passed")
+        print(f"Installed wheel smoke passed: {wheel.name}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -1,29 +1,29 @@
 {
   "src/agent/client-skills.test.ts": 1134,
   "src/agent/memory-git.ts": 2097,
-  "src/backend/local-backend.test.ts": 2532,
-  "src/backend/local/local-backend.ts": 1012,
-  "src/backend/local/local-store.ts": 3459,
-  "src/backend/pi-stream-adapter.test.ts": 1304,
-  "src/cli/app/AppCoordinator.tsx": 5141,
+  "src/backend/local-backend.test.ts": 2473,
+  "src/backend/local/local-backend.ts": 1005,
+  "src/backend/local/local-store.ts": 3457,
+  "src/backend/pi-stream-adapter.test.ts": 1255,
+  "src/cli/app/AppCoordinator.tsx": 5138,
   "src/cli/app/AppView.tsx": 1735,
   "src/cli/app/use-approval-flow.ts": 1163,
-  "src/cli/app/use-configuration-handlers.ts": 1421,
+  "src/cli/app/use-configuration-handlers.ts": 1418,
   "src/cli/app/use-conversation-loop.ts": 2903,
-  "src/cli/app/use-submit-handler.ts": 3979,
+  "src/cli/app/use-submit-handler.ts": 3804,
   "src/cli/components/AgentSelector.tsx": 1104,
   "src/cli/components/InputRich.tsx": 2225,
   "src/cli/components/ModelSelector.tsx": 1259,
-  "src/cli/components/ProviderSelector.tsx": 1692,
+  "src/cli/components/ProviderSelector.tsx": 1564,
   "src/cli/components/ToolCallMessageRich.tsx": 1013,
   "src/cli/helpers/accumulator.ts": 1592,
   "src/cli/helpers/reflection-transcript.ts": 1926,
   "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": 4824,
+  "src/headless.ts": 4808,
   "src/hooks/integration.test.ts": 1147,
-  "src/index.ts": 2612,
+  "src/index.ts": 2606,
   "src/mods/learning-harness.ts": 2434,
   "src/mods/mod-engine.test.ts": 2153,
   "src/mods/mod-engine.ts": 1838,
@@ -34,14 +34,14 @@
   "src/permissions/read-only-shell.ts": 1969,
   "src/providers/chatgpt-usage-service.ts": 1112,
   "src/settings-manager.test.ts": 1635,
-  "src/settings-manager.ts": 2102,
-  "src/tools/manager.ts": 2904,
-  "src/tools/tool-execution-context.test.ts": 1136,
+  "src/settings-manager.ts": 2101,
+  "src/tools/manager.ts": 2798,
+  "src/tools/tool-execution-context.test.ts": 1114,
   "src/types/protocol_v2.ts": 2593,
   "src/websocket/listen-client-concurrency.test.ts": 2666,
   "src/websocket/listen-client-protocol.test.ts": 5762,
   "src/websocket/listener/commands/memory.ts": 1114,
   "src/websocket/listener/file-commands.ts": 1053,
-  "src/websocket/listener/protocol-inbound.ts": 2137,
+  "src/websocket/listener/protocol-inbound.ts": 2126,
   "src/websocket/listener/protocol-outbound.ts": 1022
 }

package/scripts/stage-pypi-deps.mjs

@@ -0,0 +1,90 @@
+// Copy the locked runtime dependency closure, preserving Node's nested versions.
+// No dependency installation happens on the user's machine.
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+const root = process.cwd();
+const app = resolve(process.argv[2]);
+// sharp-electron is only reachable under Electron, never our bundled Node.
+const roots = ["ws", "@vscode/ripgrep", "node-pty", "grammy"];
+
+function locate(name, from) {
+  for (let dir = from; ; dir = dirname(dir)) {
+    const candidate = join(dir, "node_modules", name);
+    if (existsSync(join(candidate, "package.json")))
+      return realpathSync(candidate);
+    if (dir === dirname(dir))
+      throw new Error(`Missing locked dependency ${name} from ${from}`);
+  }
+}
+function compatible(pkg) {
+  return (
+    (!pkg.os || pkg.os.includes(process.platform)) &&
+    (!pkg.cpu || pkg.cpu.includes(process.arch)) &&
+    (!pkg.libc || pkg.libc.includes("glibc"))
+  );
+}
+function copy(name, from, dest, ancestors = new Set()) {
+  const source = locate(name, from);
+  const pkg = JSON.parse(readFileSync(join(source, "package.json")));
+  if (!compatible(pkg)) return;
+  if (ancestors.has(source)) throw new Error(`Dependency cycle at ${source}`);
+  const target = join(dest, "node_modules", name);
+  mkdirSync(dirname(target), { recursive: true });
+  cpSync(source, target, {
+    recursive: true,
+    dereference: true,
+    filter: (path) =>
+      path === source ||
+      !["node_modules", ".git"].includes(
+        path.slice(source.length + 1).split(/[\\/]/)[0],
+      ),
+  });
+  const chain = new Set([...ancestors, source]);
+  const optional = pkg.optionalDependencies || {};
+  for (const dependency of Object.keys({ ...pkg.dependencies, ...optional })) {
+    try {
+      locate(dependency, source);
+    } catch (error) {
+      if (dependency in optional) continue;
+      throw error;
+    }
+    copy(dependency, source, target, chain);
+  }
+}
+for (const name of roots) copy(name, root, app);
+// Bun bundles Sharp JS but leaves its computed @img native requires unresolved.
+const sharp = locate("sharp", root);
+const sharpPackage = JSON.parse(readFileSync(join(sharp, "package.json")));
+for (const name of Object.keys(sharpPackage.optionalDependencies || {})) {
+  try {
+    locate(name, sharp);
+  } catch {
+    continue;
+  }
+  copy(name, sharp, app);
+}
+
+// Retain license notices for code in the JS bundle as well as external modules.
+function licenses(dir, destination) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory() && entry.name !== ".bin")
+      licenses(path, join(destination, entry.name));
+    else if (
+      entry.isFile() &&
+      /^(licen[sc]e|copying|notice)([.-]|$)/i.test(entry.name)
+    ) {
+      mkdirSync(destination, { recursive: true });
+      cpSync(path, join(destination, entry.name));
+    }
+  }
+}
+licenses(join(root, "node_modules"), join(app, "third-party-licenses"));

package/skills/creating-mods/references/plan-mode.md

@@ -109,7 +109,7 @@ In plan mode, you should:
 Remember: DO NOT write or edit any files except the plan file. This is a read-only exploration and planning phase.
 
 Plan file path: ${session.planFilePath}
-If using apply_patch, use this exact relative patch path: ${relativePatchPath}`;
+If using ApplyPatch, use this exact relative patch path: ${relativePatchPath}`;
 }
 
 export default function activate(letta) {
@@ -161,7 +161,7 @@ function buildActiveReminder(session, cwd) {
 Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits (with the exception of the plan file mentioned below), run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received. Instead, you should:
 1. Answer the user's query comprehensively, using the AskUserQuestion tool if you need to ask the user clarifying questions.
 2. Write your implementation plan to the plan file. Plan file path: ${session.planFilePath}
-3. If using apply_patch, use this exact relative path in patch headers: ${relativePatchPath}
+3. If using ApplyPatch, use this exact relative path in patch headers: ${relativePatchPath}
 4. Use direct read-only tools for exploration. Do not launch coding, general-purpose, or fork subagents in plan mode; they may mutate files and should be denied. Only recall-style subagents are allowed if available.
 5. When the plan is complete, read the plan file and present the full current plan text to the user with AskUserQuestion. The question body must include the entire plan, not a summary. The question should offer at least "Approve" and "Revise" options.
 6. If the user approves, call exit_plan_mode immediately. If the user asks to revise, stay in plan mode, update the plan file, then read and present the full revised plan again.
@@ -180,26 +180,21 @@ if (letta.capabilities.events.turns) {
 
 ## Permission overlay
 
-Use a permission overlay, not `tool_start`, for policy. Normalize tool names by family; UI display names and provider-specific tool names drift (`Read`, `read`, `read_file`, `ReadFile`, `SearchFileContent`, etc.). Keep pure read-only tools separate from planning coordination tools like `AskUserQuestion` and todo/plan updates so the policy stays honest.
+Use a permission overlay, not `tool_start`, for policy. Normalize tool names by family; UI display names and provider-specific tool names drift (`Read`, `read`, `read_file`, `ReadFile`, etc.). Keep pure read-only tools separate from planning coordination tools like `AskUserQuestion` and todo/plan updates so the policy stays honest.
 
 ```ts
 const readOnlyToolNames = new Set([
   "glob",
-  "globgemini",
   "grep",
   "grepfiles",
   "list",
   "listdir",
-  "listdirectory",
   "ls",
   "notebookread",
   "read",
   "readfile",
-  "readfilegemini",
   "readlsp",
-  "readmanyfiles",
   "search",
-  "searchfilecontent",
   "searchfiles",
   "skill",
   "taskoutput",
@@ -212,7 +207,6 @@ const planningToolNames = new Set([
   "exitplanmode",
   "todowrite",
   "updateplan",
-  "writetodos",
 ]);
 
 const readOnlySubagentTypes = new Set(["recall"]);