@letta-ai/letta-code 0.34.24 → 0.34.26

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

@@ -52,17 +52,121 @@ describe("Codex stable release range", () => {
 });
 
 describe("Codex GitHub release fetch", () => {
+  test("resolves latest without fetching a list page when the cursor is current", async () => {
+    const urls: string[] = [];
+    const releases = await listStableReleases({
+      sinceTag: "rust-v0.3.0",
+      fetchImpl: (async (input) => {
+        urls.push(String(input));
+        return Response.json(STABLES[2]);
+      }) as typeof fetch,
+    });
+
+    expect(releases).toEqual([STABLES[2]]);
+    expect(urls).toEqual([
+      "https://api.github.com/repos/openai/codex/releases/latest",
+    ]);
+  });
+
+  test("resolves an explicit current tag without fetching a list page", async () => {
+    const urls: string[] = [];
+    const releases = await listStableReleases({
+      currentTag: "rust-v0.2.0",
+      sinceTag: "rust-v0.2.0",
+      fetchImpl: (async (input) => {
+        const url = String(input);
+        urls.push(url);
+        return Response.json(url.endsWith("/latest") ? STABLES[2] : STABLES[1]);
+      }) as typeof fetch,
+    });
+
+    expect(releases).toEqual([STABLES[1], STABLES[2]]);
+    expect(urls).toEqual([
+      "https://api.github.com/repos/openai/codex/releases/latest",
+      "https://api.github.com/repos/openai/codex/releases/tags/rust-v0.2.0",
+    ]);
+  });
+
+  test("bounds pagination after finding the adjacent stable release", async () => {
+    const urls: string[] = [];
+    const prereleases = Array.from({ length: 100 }, (_, index) => ({
+      ...release(
+        `rust-v1.0.${index}`,
+        `2026-09-01T00:${String(index % 60).padStart(2, "0")}:00Z`,
+      ),
+      prerelease: true,
+    }));
+    const releases = await listStableReleases({
+      fetchImpl: (async (input) => {
+        const url = String(input);
+        urls.push(url);
+        if (url.endsWith("/latest")) return Response.json(STABLES[2]);
+        if (url.endsWith("page=1")) return Response.json(prereleases);
+        if (url.endsWith("page=2")) return Response.json([STABLES[1]]);
+        throw new Error(`Unexpected request ${url}`);
+      }) as typeof fetch,
+    });
+
+    expect(releases).toEqual([STABLES[1], STABLES[2]]);
+    expect(urls.filter((url) => url.includes("?per_page=100"))).toHaveLength(2);
+  });
+
+  test("stops range pagination as soon as the since tag is found", async () => {
+    const urls: string[] = [];
+    const fullPage = Array.from({ length: 100 }, (_, index) => ({
+      ...release(
+        `rust-v1.0.${index}`,
+        `2026-09-01T00:${String(index % 60).padStart(2, "0")}:00Z`,
+      ),
+      prerelease: true,
+    }));
+    await listStableReleases({
+      currentTag: "rust-v0.3.0",
+      sinceTag: "rust-v0.1.0",
+      fetchImpl: (async (input) => {
+        const url = String(input);
+        urls.push(url);
+        if (url.endsWith("/latest")) return Response.json(STABLES[2]);
+        if (url.endsWith("/tags/rust-v0.3.0")) return Response.json(STABLES[2]);
+        if (url.endsWith("page=1")) return Response.json(fullPage);
+        if (url.endsWith("page=2")) return Response.json(STABLES.slice(0, 2));
+        throw new Error(`Unexpected request ${url}`);
+      }) as typeof fetch,
+    });
+
+    expect(urls.filter((url) => url.includes("?per_page=100"))).toHaveLength(2);
+  });
+
+  test("reports a missing explicit current tag without listing releases", async () => {
+    const urls: string[] = [];
+    const result = listStableReleases({
+      currentTag: "rust-v9.9.9",
+      fetchImpl: (async (input) => {
+        const url = String(input);
+        urls.push(url);
+        if (url.endsWith("/latest")) return Response.json(STABLES[2]);
+        return new Response("Not Found", { status: 404 });
+      }) as typeof fetch,
+    });
+
+    await expect(result).rejects.toThrow(
+      "GitHub releases API failed (404): Not Found",
+    );
+    expect(urls.some((url) => url.includes("?per_page=100"))).toBe(false);
+  });
+
   test("retries a server error before succeeding", async () => {
     const sleeps: number[] = [];
     let requests = 0;
 
     const releases = await listStableReleases({
+      sinceTag: "rust-v0.3.0",
       fetchImpl: (async () => {
         requests++;
         if (requests === 1) {
           return new Response("Gateway Timeout", { status: 504 });
         }
-        return new Response(JSON.stringify(STABLES), { status: 200 });
+        return Response.json(STABLES[2]);
       }) as typeof fetch,
       sleep: async (delayMs) => {
         sleeps.push(delayMs);
@@ -71,7 +175,7 @@ describe("Codex GitHub release fetch", () => {
 
     expect(requests).toBe(2);
     expect(sleeps).toEqual([1000]);
-    expect(releases).toEqual(STABLES);
+    expect(releases).toEqual([STABLES[2]]);
   });
 
   test("retries a network error before succeeding", async () => {
@@ -79,10 +183,11 @@ describe("Codex GitHub release fetch", () => {
     let requests = 0;
 
     const releases = await listStableReleases({
+      sinceTag: "rust-v0.3.0",
       fetchImpl: (async () => {
         requests++;
         if (requests === 1) throw new TypeError("fetch failed: ECONNRESET");
-        return new Response(JSON.stringify(STABLES), { status: 200 });
+        return Response.json(STABLES[2]);
       }) as typeof fetch,
       sleep: async (delayMs) => {
         sleeps.push(delayMs);
@@ -91,7 +196,7 @@ describe("Codex GitHub release fetch", () => {
 
     expect(requests).toBe(2);
     expect(sleeps).toEqual([1000]);
-    expect(releases).toEqual(STABLES);
+    expect(releases).toEqual([STABLES[2]]);
   });
 
   test("stops after the bounded retry budget", async () => {
@@ -115,6 +220,77 @@ describe("Codex GitHub release fetch", () => {
     expect(sleeps).toEqual([1000, 2000]);
   });
 
+  test("retries a disconnected successful response body", async () => {
+    const sleeps: number[] = [];
+    let requests = 0;
+    const releases = await listStableReleases({
+      sinceTag: "rust-v0.3.0",
+      fetchImpl: (async () => {
+        requests++;
+        if (requests === 1) {
+          return new Response(
+            new ReadableStream({
+              pull(controller) {
+                controller.error(new TypeError("fetch failed: ECONNRESET"));
+              },
+            }),
+            { status: 200 },
+          );
+        }
+        return Response.json(STABLES[2]);
+      }) as typeof fetch,
+      sleep: async (delayMs) => {
+        sleeps.push(delayMs);
+      },
+    });
+
+    expect(requests).toBe(2);
+    expect(sleeps).toEqual([1000]);
+    expect(releases).toEqual([STABLES[2]]);
+  });
+
+  test("stops retrying disconnected bodies at the existing budget", async () => {
+    const sleeps: number[] = [];
+    let requests = 0;
+    const result = listStableReleases({
+      fetchImpl: (async () => {
+        requests++;
+        return new Response(
+          new ReadableStream({
+            pull(controller) {
+              controller.error(new TypeError("fetch failed: ECONNRESET"));
+            },
+          }),
+        );
+      }) as typeof fetch,
+      sleep: async (delayMs) => {
+        sleeps.push(delayMs);
+      },
+    });
+
+    await expect(result).rejects.toThrow("after 3 attempts");
+    expect(requests).toBe(3);
+    expect(sleeps).toEqual([1000, 2000]);
+  });
+
+  test("does not retry malformed JSON", async () => {
+    const sleeps: number[] = [];
+    let requests = 0;
+    const result = listStableReleases({
+      fetchImpl: (async () => {
+        requests++;
+        return new Response("not JSON");
+      }) as typeof fetch,
+      sleep: async (delayMs) => {
+        sleeps.push(delayMs);
+      },
+    });
+
+    await expect(result).rejects.toBeInstanceOf(SyntaxError);
+    expect(requests).toBe(1);
+    expect(sleeps).toEqual([]);
+  });
+
   test("fails immediately on a client error", async () => {
     const sleeps: number[] = [];
     let requests = 0;

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

@@ -63,7 +63,12 @@ export interface CodexWatchAnalysis {
 export async function analyzeCodexRelease(
   options: AnalyzeCodexReleaseOptions,
 ): Promise<CodexWatchAnalysis> {
-  const stables = options.stableReleases ?? (await listStableReleases());
+  const stables =
+    options.stableReleases ??
+    (await listStableReleases({
+      currentTag: options.currentTag,
+      sinceTag: options.sinceTag,
+    }));
   if (stables.length === 0) throw new Error("No stable Codex releases found");
 
   const current = options.currentTag
@@ -173,6 +178,9 @@ export async function listStableReleases(
   options: {
     fetchImpl?: typeof fetch;
     sleep?: (delayMs: number) => Promise<void>;
+    currentTag?: string | null;
+    sinceTag?: string | null;
+    fullHistory?: boolean;
   } = {},
 ): Promise<Release[]> {
   const releases: Release[] = [];
@@ -188,29 +196,80 @@ export async function listStableReleases(
     ((delayMs: number) =>
       new Promise<void>((resolve) => setTimeout(resolve, delayMs)));
 
+  if (!options.fullHistory) {
+    const latest = await fetchGitHubReleasePayload<Release>(
+      `https://api.github.com/repos/${CODEX_REPO}/releases/latest`,
+      headers,
+      fetchImpl,
+      sleep,
+    );
+    releases.push(latest);
+    if (options.currentTag) {
+      releases.push(
+        await fetchGitHubReleasePayload<Release>(
+          `https://api.github.com/repos/${CODEX_REPO}/releases/tags/${encodeURIComponent(options.currentTag)}`,
+          headers,
+          fetchImpl,
+          sleep,
+        ),
+      );
+    }
+
+    const currentTag = options.currentTag ?? latest.tag_name;
+    if (options.sinceTag && options.sinceTag === currentTag) {
+      return stableReleases(releases);
+    }
+  }
+
   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 fetchGitHubReleasesPage(url, headers, fetchImpl, sleep);
-    const batch = (await res.json()) as Release[];
+    const batch = await fetchGitHubReleasePayload<Release[]>(
+      url,
+      headers,
+      fetchImpl,
+      sleep,
+    );
     releases.push(...batch);
+    if (!options.fullHistory) {
+      const stables = stableReleases(releases);
+      const currentTag = options.currentTag ?? stables.at(-1)?.tag_name;
+      const currentIndex = stables.findIndex(
+        (release) => release.tag_name === currentTag,
+      );
+      const foundBoundary = options.sinceTag
+        ? stables.some((release) => release.tag_name === options.sinceTag)
+        : currentIndex > 0;
+      if (foundBoundary) break;
+    }
     if (batch.length < 100) break;
   }
-  return releases
+  return stableReleases(releases);
+}
+
+function stableReleases(releases: Release[]): Release[] {
+  const byTag = new Map<string, Release>();
+  for (const release of releases) {
+    if (!byTag.has(release.tag_name)) byTag.set(release.tag_name, release);
+  }
+  return [...byTag.values()]
     .filter(isStableRelease)
     .sort((a, b) => (a.published_at ?? "").localeCompare(b.published_at ?? ""));
 }
 
-async function fetchGitHubReleasesPage(
+async function fetchGitHubReleasePayload<T>(
   url: string,
   headers: Record<string, string>,
   fetchImpl: typeof fetch,
   sleep: (delayMs: number) => Promise<void>,
-): Promise<Response> {
+): Promise<T> {
   for (let attempt = 1; ; attempt++) {
     let response: Response;
     try {
       response = await fetchImpl(url, { headers });
+      // A successful fetch can still lose its connection while reading the body.
+      if (response.ok) return (await response.json()) as T;
     } catch (error) {
+      if (error instanceof SyntaxError) throw error;
       if (attempt === GITHUB_RELEASES_FETCH_ATTEMPTS) {
         throw new Error(
           `GitHub releases API request failed after ${attempt} attempts: ${String(error)}`,
@@ -221,8 +280,6 @@ async function fetchGitHubReleasesPage(
       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);

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

@@ -13,13 +13,14 @@
   "src/cli/components/AgentSelector.tsx": 1104,
   "src/cli/components/InputRich.tsx": 2124,
   "src/cli/components/ModelSelector.tsx": 1259,
-  "src/cli/components/ProviderSelector.tsx": 1552,
+  "src/cli/components/ProviderSelector.tsx": 1544,
   "src/cli/helpers/accumulator.ts": 1587,
   "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": 4851,
+  "src/cli/subcommands/mcp.ts": 1045,
+  "src/cli/subcommands/skills.ts": 1243,
+  "src/headless.ts": 4837,
   "src/hooks/integration.test.ts": 1147,
   "src/index.ts": 2575,
   "src/mods/learning-harness.ts": 2434,
@@ -35,7 +36,7 @@
   "src/tools/manager.ts": 2609,
   "src/tools/tool-execution-context.test.ts": 1092,
   "src/types/protocol_v2.ts": 2409,
-  "src/websocket/listen-client-concurrency.test.ts": 2554,
+  "src/websocket/listen-client-concurrency.test.ts": 2548,
   "src/websocket/listen-client-protocol.test.ts": 5664,
   "src/websocket/listener/commands/memory.ts": 1114,
   "src/websocket/listener/file-commands.ts": 1045,

package/skills/initializing-memory/SKILL.md

@@ -7,7 +7,7 @@ description: Comprehensive guide for initializing or reorganizing agent memory.
 
 Your memory is projected to a filesystem at `$MEMORY_DIR`, so you can restructure it with ordinary file tools and git. This skill applies the [Context Constitution](https://github.com/letta-ai/context-constitution/blob/main/constitution/CONSTITUTION.md)'s Progressive Disclosure and Efficiency principles to the [MemFS v2 root-first design](https://github.com/letta-ai/letta-code/blob/main/src/agent/prompts/letta_root_memfs.md).
 
-**You own this task through completion**: research, ask, synthesize, write, commit, verify. Delegate research, but integrate the results yourself — launching a background task is not completion. If a memory worker you launched is still editing this checkout, wait for it, then re-read before editing.
+**You own this task through completion**: research, ask, synthesize, write, commit, verify. Delegate research, but integrate the results yourself — launching a background task is not completion.
 
 ## Principles
 

package/skills/maintaining-deferred-memory/SKILL.md

@@ -58,6 +58,8 @@ Discovery runs through the `MEMORY.md` chain, one level at a time:
 
 After adding or moving a file, trace the path a future request would take from root `MEMORY.md` to the file. If any step depends on knowing the file already exists, fix the index.
 
+Indexes are the only way the agent finds deferred memory: it opens a file only when every entry on the path from root names what it is looking for. Keep them accurate as memory changes. Whenever you add, move, or substantially change what a directory holds, reread its entry in each parent `MEMORY.md` up to root and rewrite it to name the topics the directory now covers, in the words a future request would use. An entry written when the directory was new goes stale as it fills, and a topic no entry mentions is effectively lost.
+
 ## Design for progressive disclosure
 
 Each level should give the agent enough to decide whether to go deeper, and nothing it would have to read past to decide.

package/skills/managing-agent-webhooks/SKILL.md

@@ -96,11 +96,13 @@ payload as a user message.
   unreadable receipt means deletion was accepted but remains unconfirmed; list
   webhooks before treating the capability URL as removed or retrying.
 - Normal update output additionally requires the returned webhook ID and
-  `enabled` state to match the requested operation; normal rotate output
-  requires the returned webhook ID to match. Canonical but contradictory 2xx
+  `enabled` state (or `target_device_id` for `update --computer`) to match the
+  requested operation; normal rotate output requires the returned webhook ID
+  to match. Canonical but contradictory 2xx
   records receive the same accepted/reconcile envelope and are never printed as
   ordinary success.
-- Normal create output also requires returned name and enabled state to match.
+- Normal create output also requires returned name, enabled state, and
+  `target_device_id` to match.
   An explicitly supplied preprompt must round-trip exactly; when preprompt is
   omitted, the server-owned default is accepted only as a nonblank string, while
   missing, null, empty, whitespace-only, and non-string values are contradictory.
@@ -207,6 +209,24 @@ The caller sends `Authorization: Basic <base64("webhook:<security-key>")>`.
 Do not print that header or the key. The helper derives it internally for test
 requests when the same key is piped through stdin.
 
+### Run webhook turns on a connected computer
+
+By default, webhook-triggered conversations run in the agent's Cloud sandbox.
+To run them on a connected computer instead, get its device ID from
+`letta computers list` and pass it with `--computer` on `create` or `update`:
+
+```bash
+node <SKILL_DIR>/scripts/manage-agent-webhooks.mjs update \
+  --webhook-id webhook-agent-... \
+  --computer <deviceId>
+```
+
+`list` shows the target as `target_device_id` (`null` means Cloud). If the
+computer is offline when a request arrives, that delivery fails; it does not
+fall back to Cloud. An unknown device ID returns `404 targetDeviceNotFound`.
+Pass `--computer cloud` to `update` to clear the target and go back to the
+Cloud sandbox.
+
 ### Test acceptance
 
 Public webhook:

package/skills/managing-agent-webhooks/scripts/manage-agent-webhooks.mjs

@@ -15,6 +15,7 @@ const COMMANDS = new Set([
   "requests",
   "rotate",
   "test",
+  "update",
 ]);
 const BOOLEAN_FLAGS = new Set([
   "confirm",
@@ -28,6 +29,7 @@ const COMMAND_OPTIONS = new Map([
   [
     "create",
     new Set([
+      "computer",
       "credential-output",
       "disabled",
       "name",
@@ -53,12 +55,14 @@ const COMMAND_OPTIONS = new Map([
       "webhook-id",
     ]),
   ],
+  ["update", new Set(["computer", "webhook-id"])],
 ]);
 
 function usage() {
   console.error(`Usage:
   node manage-agent-webhooks.mjs list
-  node manage-agent-webhooks.mjs create --name <name> (--public | --secure --credential-output <path> | --security-key-stdin) [--preprompt <text>] [--disabled]
+  node manage-agent-webhooks.mjs create --name <name> (--public | --secure --credential-output <path> | --security-key-stdin) [--preprompt <text>] [--disabled] [--computer <deviceId>]
+  node manage-agent-webhooks.mjs update --webhook-id <id> --computer <deviceId|cloud>
   node manage-agent-webhooks.mjs test --webhook-id <id> --confirm [--payload-file <path>] [--credential-file <path> | --security-key-stdin]
   node manage-agent-webhooks.mjs requests --webhook-id <id> [--limit <1-50>] [--include-body]
   node manage-agent-webhooks.mjs enable --webhook-id <id>
@@ -144,8 +148,10 @@ export function safeAgentWebhook(webhook) {
   for (const field of ["enabled", "requires_authorization_header"]) {
     if (typeof webhook[field] === "boolean") safe[field] = webhook[field];
   }
-  if (typeof webhook.disabled_at === "string" || webhook.disabled_at === null) {
-    safe.disabled_at = webhook.disabled_at;
+  for (const field of ["disabled_at", "target_device_id"]) {
+    if (typeof webhook[field] === "string" || webhook[field] === null) {
+      safe[field] = webhook[field];
+    }
   }
   return safe;
 }
@@ -753,6 +759,15 @@ function requireWebhookId(args) {
   return requireString(args["webhook-id"], "Pass --webhook-id");
 }
 
+// "cloud" maps to null: run webhook turns in the agent's Cloud sandbox.
+function targetDeviceIdFromArgs(args) {
+  const computer = requireString(
+    args.computer,
+    "--computer must be a device ID or cloud",
+  );
+  return computer === "cloud" ? null : computer;
+}
+
 function requireConfirmation(args, action) {
   if (args.confirm !== true) {
     throw new Error(`${action} requires --confirm`);
@@ -827,6 +842,10 @@ async function runManagementCommand(params) {
         "--preprompt must contain a non-whitespace character",
       );
     }
+    if (params.args.computer !== undefined) {
+      const targetDeviceId = targetDeviceIdFromArgs(params.args);
+      if (targetDeviceId) body.target_device_id = targetDeviceId;
+    }
     if (securityKey) body.security_key = securityKey;
     const credentialReservation = usesGeneratedCredential
       ? await reserveCredentialFile(params.args["credential-output"])
@@ -914,6 +933,8 @@ async function runManagementCommand(params) {
       if (
         webhook.name !== body.name ||
         webhook.enabled !== body.enabled ||
+        (webhook.target_device_id ?? null) !==
+          (body.target_device_id ?? null) ||
         !prepromptMatches
       ) {
         throw new Error(
@@ -1048,14 +1069,22 @@ async function runManagementCommand(params) {
     return;
   }
 
-  if (params.command === "enable" || params.command === "disable") {
+  if (
+    params.command === "enable" ||
+    params.command === "disable" ||
+    params.command === "update"
+  ) {
     if (params.command === "disable") {
       requireConfirmation(params.args, "Disabling a webhook");
     }
+    const update =
+      params.command === "update"
+        ? { target_device_id: targetDeviceIdFromArgs(params.args) }
+        : { enabled: params.command === "enable" };
     const mutation = await requestSideEffect(
       itemUrl,
       {
-        body: JSON.stringify({ enabled: params.command === "enable" }),
+        body: JSON.stringify(update),
         headers: params.headers,
         method: "PATCH",
       },
@@ -1074,12 +1103,12 @@ async function runManagementCommand(params) {
         params.baseUrl,
         params.agentId,
       );
-      const expectedEnabled = params.command === "enable";
-      if (
-        webhook.id !== webhookId ||
-        typeof webhook.enabled !== "boolean" ||
-        webhook.enabled !== expectedEnabled
-      ) {
+      const stateMatches =
+        params.command === "update"
+          ? webhook.target_device_id === update.target_device_id
+          : typeof webhook.enabled === "boolean" &&
+            webhook.enabled === update.enabled;
+      if (webhook.id !== webhookId || !stateMatches) {
         throw new Error(
           "Update response does not match the requested webhook state",
         );

package/skills/self-configuration/SKILL.md

@@ -110,7 +110,7 @@ Use the active layout shown by the prompt and memory files. Do not create a
 `system/` directory in a root-layout repository or move existing-layout memory
 to the root as part of an unrelated self-configuration request.
 
-A requested memory or identity change is memory as the main task: make the edit directly with ordinary file tools, preserve the active layout, stage only the files you changed by explicit path, commit in the same shell call, and verify the result before reporting success. If a memory worker you launched may still be running, read its output file first (it ends with `[Task completed]` or `[Task failed]`) and reread the files before editing what it was asked to change. Delegate to the background `memory` subagent only when the change is incidental to another task the user is waiting on.
+Before editing memory, load the relevant skills: `maintaining-core-memory` for root/core files, `maintaining-deferred-memory` for deferred files, and `creating-skills` for skills. Then make the edit directly with ordinary file tools so the agent with the context applies the memory guidance. Preserve the active layout, stage only changed files by explicit path, commit in the same shell call, and verify the result before reporting success.
 
 Do not use API system-prompt replacement for ordinary learning. That can clobber the compiled prompt. Edit the memory files instead.
 

package/skills/syncing-memory-filesystem/SKILL.md

@@ -5,15 +5,7 @@ description: Diagnose and repair MemFS repository setup, remote sync, authentica
 
 # MemFS Repository Repair
 
-Use this skill only when the Git repository behind an agent's memory is not
-setting up or syncing correctly. For ordinary memory reads and edits, use the
-memory files without loading this skill. Delegate incidental upkeep during another
-task to the background `memory` subagent. When memory repair is the user's main
-request, diagnose and repair it directly, then verify the result before reporting
-success. If a memory worker you launched may still be running, wait for it: re-read
-its output file until it ends with `[Task completed]` or `[Task failed]` before
-editing memory files or changing Git state. While the harness reports a repair in
-progress, leave both alone as well; that worker edits `$MEMORY_DIR` in place.
+Use this skill when the Git repository behind an agent's memory is not setting up or syncing correctly. Before editing memory, load the relevant skills: `maintaining-core-memory` for root/core files, `maintaining-deferred-memory` for deferred files, and `creating-skills` for skills. Then make the edit directly with ordinary file tools so the agent with the context applies the memory guidance. Stage only changed files by explicit path and commit in the same shell call. Verify the repair before reporting success. While the harness reports a repair in progress, leave memory files and Git state to that repair worker, which edits `$MEMORY_DIR` in place.
 
 ## Current Model
 
@@ -122,7 +114,7 @@ cloud-backed agent's pending commits after the turn.
 The harness first tries a fast-forward pull. When a remote push is rejected
 because the remote moved, post-turn sync tries `git pull --rebase` and retries
 the push. If that rebase conflicts, the harness launches a fresh background
-`memory` subagent to repair it. The primary conversation is not interrupted.
+internal `memory` subagent to repair it. The primary conversation is not interrupted.
 The harness retries normal sync after the worker finishes. The instructions
 below are for explicit troubleshooting; routine repairs run in the background.