@letta-ai/letta-code 0.30.32 → 0.31.0

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

@@ -1,7 +1,7 @@
 import {
-  areAdjacentStableReleases,
-  findNextStableRelease,
+  findLatestStableReleaseAfter,
   type Release,
+  releaseNotesForRange,
 } from "./release-analysis.ts";
 
 function release(tag: string, publishedAt: string): Release {
@@ -10,7 +10,7 @@ function release(tag: string, publishedAt: string): Release {
     draft: false,
     prerelease: false,
     html_url: `https://github.com/openai/codex/releases/tag/${tag}`,
-    body: null,
+    body: `Notes for ${tag}`,
     published_at: publishedAt,
   };
 }
@@ -21,28 +21,30 @@ const STABLES = [
   release("rust-v0.3.0", "2026-08-03T00:00:00Z"),
 ];
 
-describe("Codex stable release backlog", () => {
-  test("selects the first release after the durable cursor", () => {
-    expect(findNextStableRelease(STABLES, "rust-v0.1.0")?.tag_name).toBe(
-      "rust-v0.2.0",
+describe("Codex stable release range", () => {
+  test("selects the latest release after the durable cursor", () => {
+    expect(findLatestStableReleaseAfter(STABLES, "rust-v0.1.0")?.tag_name).toBe(
+      "rust-v0.3.0",
     );
   });
 
-  test("identifies only adjacent stable release pairs", () => {
-    expect(
-      areAdjacentStableReleases(STABLES, "rust-v0.1.0", "rust-v0.2.0"),
-    ).toBe(true);
-    expect(
-      areAdjacentStableReleases(STABLES, "rust-v0.1.0", "rust-v0.3.0"),
-    ).toBe(false);
+  test("includes release notes for the full cursor-to-latest range", () => {
+    const notes = releaseNotesForRange(STABLES, "rust-v0.1.0", "rust-v0.3.0");
+    expect(notes).toContain("## [rust-v0.2.0]");
+    expect(notes).toContain("Notes for rust-v0.2.0");
+    expect(notes).toContain("## [rust-v0.3.0]");
+    expect(notes).not.toContain("Notes for rust-v0.1.0");
+    expect(() =>
+      releaseNotesForRange(STABLES, "rust-v0.3.0", "rust-v0.2.0"),
+    ).toThrow("Previous release rust-v0.3.0 must precede rust-v0.2.0");
   });
 
   test("returns null when the durable cursor is current", () => {
-    expect(findNextStableRelease(STABLES, "rust-v0.3.0")).toBeNull();
+    expect(findLatestStableReleaseAfter(STABLES, "rust-v0.3.0")).toBeNull();
   });
 
   test("fails instead of skipping an unavailable cursor", () => {
-    expect(() => findNextStableRelease(STABLES, "rust-v0.0.9")).toThrow(
+    expect(() => findLatestStableReleaseAfter(STABLES, "rust-v0.0.9")).toThrow(
       "Could not find terminal release rust-v0.0.9",
     );
   });

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

@@ -45,7 +45,7 @@ export interface PathChangeSummary {
 export interface CodexWatchAnalysis {
   previous_tag: string;
   current_tag: string;
-  is_adjacent_release: boolean;
+  is_latest_release: boolean;
   release_url: string;
   release_notes_md: string;
   verdict: Verdict;
@@ -139,13 +139,13 @@ export async function analyzeCodexRelease(
     return {
       previous_tag: previous.tag_name,
       current_tag: current.tag_name,
-      is_adjacent_release: areAdjacentStableReleases(
+      is_latest_release: current.tag_name === stables.at(-1)?.tag_name,
+      release_url: current.html_url,
+      release_notes_md: releaseNotesForRange(
         stables,
         previous.tag_name,
         current.tag_name,
       ),
-      release_url: current.html_url,
-      release_notes_md: current.body ?? "",
       verdict,
       models_diff: modelsDiff,
       prompt_md_changed: promptMdChanged,
@@ -207,15 +207,37 @@ function findPreviousStable(
   return stables[idx - 1] ?? null;
 }
 
-export function areAdjacentStableReleases(
+export function releaseNotesForRange(
   stables: Release[],
   previousTag: string,
   currentTag: string,
-): boolean {
-  return findPreviousStable(stables, currentTag)?.tag_name === previousTag;
+): string {
+  const currentIndex = stables.findIndex(
+    (release) => release.tag_name === currentTag,
+  );
+  if (currentIndex < 0) {
+    throw new Error(`Could not find current release ${currentTag}`);
+  }
+  const previousIndex = stables.findIndex(
+    (release) => release.tag_name === previousTag,
+  );
+  if (previousIndex >= currentIndex) {
+    throw new Error(
+      `Previous release ${previousTag} must precede ${currentTag}`,
+    );
+  }
+  const firstIncludedIndex =
+    previousIndex < 0 ? currentIndex : previousIndex + 1;
+  return stables
+    .slice(firstIncludedIndex, currentIndex + 1)
+    .map(
+      (release) =>
+        `## [${release.tag_name}](${release.html_url})\n\n${release.body?.trim() || "_No release notes._"}`,
+    )
+    .join("\n\n");
 }
 
-export function findNextStableRelease(
+export function findLatestStableReleaseAfter(
   stables: Release[],
   terminalTag: string,
 ): Release | null {
@@ -225,7 +247,7 @@ export function findNextStableRelease(
   if (terminalIndex < 0) {
     throw new Error(`Could not find terminal release ${terminalTag}`);
   }
-  return stables[terminalIndex + 1] ?? null;
+  return terminalIndex === stables.length - 1 ? null : (stables.at(-1) ?? null);
 }
 
 function cloneCodex(tmp: string): string {

package/scripts/codex-watch/tracker.test.ts

@@ -21,7 +21,7 @@ function analysis(
   return {
     previous_tag: "rust-v0.1.0",
     current_tag: tag,
-    is_adjacent_release: true,
+    is_latest_release: true,
     release_url: `https://github.com/openai/codex/releases/tag/${tag}`,
     release_notes_md: "",
     verdict,
@@ -166,7 +166,7 @@ describe("tracker state", () => {
   test("fails closed on a cumulative legacy replay", () => {
     const cumulative = {
       ...analysis("rust-v0.5.0", "tool-surface review needed"),
-      is_adjacent_release: false,
+      is_latest_release: false,
     };
     const state = recordAnalysis(emptyTrackerState(), {
       analysis: cumulative,
@@ -250,14 +250,14 @@ describe("tracker state", () => {
     expect(getCodexAuditCursorTag(state)).toBe("rust-v0.2.0");
   });
 
-  test("does not advance for an explicit non-adjacent range", () => {
+  test("does not advance for an explicit non-latest range", () => {
     const initial = upsertTrackerEntry(
       emptyTrackerState(),
       entry(1, "no_local_impact"),
     );
     const cumulative = {
       ...analysis("rust-v0.5.0", "tool-surface review needed"),
-      is_adjacent_release: false,
+      is_latest_release: false,
     };
     const state = recordAnalysis(initial, {
       analysis: cumulative,
@@ -273,7 +273,7 @@ describe("tracker state", () => {
     ).toBe("rust-v0.1.0");
   });
 
-  test("advances across an already audited adjacent range", () => {
+  test("advances across an already audited latest range", () => {
     let state = upsertTrackerEntry(
       emptyTrackerState(),
       entry(1, "no_local_impact"),

package/scripts/codex-watch/tracker.ts

@@ -119,10 +119,9 @@ export function advanceCodexAuditCursor(
   state: TrackerState,
   previousTag: string,
   currentTag: string,
-  isAdjacentRelease: boolean,
+  isLatestRelease: boolean,
 ): TrackerState {
-  if (!isAdjacentRelease || state.audit_cursor_tag !== previousTag)
-    return state;
+  if (!isLatestRelease || state.audit_cursor_tag !== previousTag) return state;
   if (!hasProcessedRange(state, previousTag, currentTag)) {
     throw new Error(
       `Cannot advance Codex audit cursor without terminal ${previousTag}...${currentTag}`,
@@ -149,26 +148,26 @@ export function recordAnalysis(
       compare_url: options.analysis.compare_url,
       workflow_run_url: options.analysis.workflow_run_url,
     },
-    options.analysis.is_adjacent_release,
+    options.analysis.is_latest_release,
   );
 }
 
 export function upsertTrackerEntry(
   state: TrackerState,
   entry: TrackerEntry,
-  advanceAuditCursor = true,
+  isLatestRelease = true,
 ): TrackerState {
   let auditCursorTag = state.audit_cursor_tag;
-  if (auditCursorTag === null && !advanceAuditCursor) {
+  if (auditCursorTag === null && !isLatestRelease) {
     auditCursorTag = entry.previous_tag;
   } else if (
-    advanceAuditCursor &&
+    isLatestRelease &&
     entry.outcome === "error" &&
     auditCursorTag === null
   ) {
     auditCursorTag = entry.previous_tag;
   } else if (
-    advanceAuditCursor &&
+    isLatestRelease &&
     isTerminalOutcome(entry.outcome) &&
     (auditCursorTag === null || entry.previous_tag === auditCursorTag)
   ) {

package/scripts/pi-ai-watch/agent-watch.ts

@@ -3,7 +3,6 @@
 import { appendFileSync, writeFileSync } from "node:fs";
 import {
   createIssueWithBody,
-  editIssueBody,
   ensureLabels,
   findIssueByExactTitle,
   getIssueBody,
@@ -13,12 +12,11 @@ import {
   analyzePiAiRelease,
   compareStableVersions,
   DEFAULT_TARGET_REPO,
-  findNextStableRelease,
+  findLatestStableReleaseAfter,
   listStableReleases,
   readInstalledVersion,
 } from "./release-analysis.ts";
 import {
-  advanceMergedPr,
   getPendingPrForCursor,
   hasCompletedRange,
   initialTrackerState,
@@ -82,7 +80,7 @@ async function main(): Promise<void> {
   const args = parseArgs(process.argv.slice(2));
   const installedVersion = readInstalledVersion();
   const tracker = ensureTrackerIssue(args, installedVersion);
-  let state = parseTrackerState(tracker.body);
+  const state = parseTrackerState(tracker.body);
   const releases = await listStableReleases();
   let previousVersion = args.previousVersion;
   let currentVersion = args.currentVersion;
@@ -109,19 +107,16 @@ async function main(): Promise<void> {
             `Merged pi-ai PR ${status.url} targets ${pending.version}, but main still declares ${installedVersion}`,
           );
         }
-        state = advanceMergedPr(state, pending.version);
-        if (!args.dryRun) {
-          editIssueBody(args.repo, tracker.number, renderTrackerBody(state));
-        }
       } else {
-        console.log(
-          `Retrying ${pending.version}; prior PR was closed unmerged.`,
-        );
+        console.log(`Prior pi-ai PR ${status.url} was closed unmerged.`);
       }
     }
 
-    const next = findNextStableRelease(releases, state.audit_cursor_version);
-    if (!next) {
+    const latest = findLatestStableReleaseAfter(
+      releases,
+      state.audit_cursor_version,
+    );
+    if (!latest) {
       console.log(
         `No stable pi-ai release after ${state.audit_cursor_version}.`,
       );
@@ -134,7 +129,7 @@ async function main(): Promise<void> {
       return;
     }
     previousVersion = state.audit_cursor_version;
-    currentVersion = next.version;
+    currentVersion = latest.version;
   }
 
   const analysis = await analyzePiAiRelease({

package/scripts/pi-ai-watch/release-analysis.test.ts

@@ -3,10 +3,9 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
-  areAdjacentStableReleases,
   compareStableVersions,
-  extractChangelogSection,
-  findNextStableRelease,
+  extractChangelogRange,
+  findLatestStableReleaseAfter,
   type PackageRelease,
   parseRegistryMetadata,
   readInstalledVersion,
@@ -59,24 +58,20 @@ describe("pi-ai npm releases", () => {
     ).toThrow("missing publication time for 0.82.1");
   });
 
-  test("selects exactly the next stable version after the cursor", () => {
+  test("selects the latest stable version after the cursor", () => {
     const releases = releaseList("0.82.1", "0.83.0", "0.84.0");
-    expect(findNextStableRelease(releases, "0.82.1")?.version).toBe("0.83.0");
-    expect(findNextStableRelease(releases, "0.84.0")).toBeNull();
-    expect(() => findNextStableRelease(releases, "0.80.0")).toThrow(
+    expect(findLatestStableReleaseAfter(releases, "0.82.1")?.version).toBe(
+      "0.84.0",
+    );
+    expect(findLatestStableReleaseAfter(releases, "0.84.0")).toBeNull();
+    expect(() => findLatestStableReleaseAfter(releases, "0.80.0")).toThrow(
       "Could not find pi-ai cursor release 0.80.0",
     );
   });
-
-  test("recognizes only adjacent release pairs", () => {
-    const releases = releaseList("0.82.1", "0.83.0", "0.84.0");
-    expect(areAdjacentStableReleases(releases, "0.82.1", "0.83.0")).toBe(true);
-    expect(areAdjacentStableReleases(releases, "0.82.1", "0.84.0")).toBe(false);
-  });
 });
 
 describe("pi-ai release evidence", () => {
-  test("extracts only the requested changelog section", () => {
+  test("extracts the cumulative changelog after the cursor", () => {
     const changelog = `# Changelog
 
 ## [0.84.0] - 2026-08-06
@@ -88,16 +83,27 @@ describe("pi-ai release evidence", () => {
 ## [0.83.0] - 2026-07-29
 
 - Previous feature.
+
+## [0.82.1] - 2026-07-20
+
+- Cursor release.
 `;
     expect(
-      extractChangelogSection(changelog, "0.84.0"),
+      extractChangelogRange(changelog, "0.82.1", "0.84.0"),
     ).toBe(`## [0.84.0] - 2026-08-06
 
 ### Added
 
-- Current feature.`);
-    expect(() => extractChangelogSection(changelog, "0.82.1")).toThrow(
-      "Could not find pi-ai changelog section 0.82.1",
+- Current feature.
+
+## [0.83.0] - 2026-07-29
+
+- Previous feature.`);
+    expect(() => extractChangelogRange(changelog, "0.80.0", "0.84.0")).toThrow(
+      "Could not find pi-ai changelog section 0.80.0",
+    );
+    expect(() => extractChangelogRange(changelog, "0.82.1", "0.85.0")).toThrow(
+      "Could not find pi-ai changelog section 0.85.0",
     );
   });
 

package/scripts/pi-ai-watch/release-analysis.ts

@@ -42,11 +42,14 @@ export interface PiAiWatchAnalysis {
   installed_version: string;
   previous_version: string;
   current_version: string;
-  is_adjacent_release: boolean;
+  is_latest_release: boolean;
   published_at: string;
   integrity: string | null;
   tarball_url: string | null;
+  previous_git_head: string | null;
   git_head: string | null;
+  previous_tag_commit: string;
+  current_tag_commit: string;
   release_url: string;
   compare_url: string;
   changelog_md: string;
@@ -79,6 +82,11 @@ export async function analyzePiAiRelease(
       `Could not find previous pi-ai release before ${current.version}`,
     );
   }
+  if (compareStableVersions(previous.version, current.version) >= 0) {
+    throw new Error(
+      `Previous pi-ai release ${previous.version} must precede ${current.version}`,
+    );
+  }
 
   const installedVersion = options.installedVersion ?? readInstalledVersion();
   const previousTag = `v${previous.version}`;
@@ -86,11 +94,13 @@ export async function analyzePiAiRelease(
   const temp = mkdtempSync(join(tmpdir(), "pi-ai-watch-"));
   try {
     const repoDir = clonePi(temp);
-    fetchTag(repoDir, previousTag);
-    fetchTag(repoDir, currentTag);
-    verifyTagMatchesPackage(repoDir, previousTag, previous);
-    verifyTagMatchesPackage(repoDir, currentTag, current);
-    const changelog = showFile(repoDir, currentTag, "packages/ai/CHANGELOG.md");
+    const previousSource = resolveReleaseSource(repoDir, previousTag, previous);
+    const currentSource = resolveReleaseSource(repoDir, currentTag, current);
+    const changelog = showFile(
+      repoDir,
+      currentSource.sourceCommit,
+      "packages/ai/CHANGELOG.md",
+    );
     if (changelog === null) {
       throw new Error(`packages/ai/CHANGELOG.md is missing at ${currentTag}`);
     }
@@ -100,24 +110,35 @@ export async function analyzePiAiRelease(
       installed_version: installedVersion,
       previous_version: previous.version,
       current_version: current.version,
-      is_adjacent_release: areAdjacentStableReleases(
-        releases,
-        previous.version,
-        current.version,
-      ),
+      is_latest_release: current.version === releases.at(-1)?.version,
       published_at: current.published_at,
       integrity: current.integrity,
       tarball_url: current.tarball_url,
+      previous_git_head: previous.git_head,
       git_head: current.git_head,
+      previous_tag_commit: previousSource.tagCommit,
+      current_tag_commit: currentSource.tagCommit,
       release_url: `https://github.com/${PI_AI_REPO}/releases/tag/${currentTag}`,
-      compare_url: `https://github.com/${PI_AI_REPO}/compare/${previousTag}...${currentTag}`,
-      changelog_md: extractChangelogSection(changelog, current.version),
-      changed_files: changedFiles(repoDir, previousTag, currentTag),
-      diff_stat: diffStat(repoDir, previousTag, currentTag),
+      compare_url: `https://github.com/${PI_AI_REPO}/compare/${previousSource.sourceCommit}...${currentSource.sourceCommit}`,
+      changelog_md: extractChangelogRange(
+        changelog,
+        previous.version,
+        current.version,
+      ),
+      changed_files: changedFiles(
+        repoDir,
+        previousSource.sourceCommit,
+        currentSource.sourceCommit,
+      ),
+      diff_stat: diffStat(
+        repoDir,
+        previousSource.sourceCommit,
+        currentSource.sourceCommit,
+      ),
       package_json_diff: diffPreview(
         repoDir,
-        previousTag,
-        currentTag,
+        previousSource.sourceCommit,
+        currentSource.sourceCommit,
         "packages/ai/package.json",
       ),
       workflow_run_url: workflowRunUrl(),
@@ -182,7 +203,7 @@ export function readInstalledVersion(lockfilePath = "bun.lock"): string {
   return match[1];
 }
 
-export function findNextStableRelease(
+export function findLatestStableReleaseAfter(
   releases: PackageRelease[],
   cursorVersion: string,
 ): PackageRelease | null {
@@ -192,33 +213,33 @@ export function findNextStableRelease(
   if (index < 0) {
     throw new Error(`Could not find pi-ai cursor release ${cursorVersion}`);
   }
-  return releases[index + 1] ?? null;
+  return index === releases.length - 1 ? null : (releases.at(-1) ?? null);
 }
 
-export function areAdjacentStableReleases(
-  releases: PackageRelease[],
+export function extractChangelogRange(
+  changelog: string,
   previousVersion: string,
   currentVersion: string,
-): boolean {
-  return (
-    findPreviousStableRelease(releases, currentVersion)?.version ===
-    previousVersion
-  );
-}
-
-export function extractChangelogSection(
-  changelog: string,
-  version: string,
 ): string {
-  const heading = new RegExp(`^## \\[${escapeRegExp(version)}\\].*$`, "m");
-  const match = heading.exec(changelog);
-  if (!match)
-    throw new Error(`Could not find pi-ai changelog section ${version}`);
-  const start = match.index;
-  const remaining = changelog.slice(start + match[0].length);
-  const next = /^## \[/m.exec(remaining);
-  const end = next ? start + match[0].length + next.index : changelog.length;
-  return changelog.slice(start, end).trim();
+  const currentHeading = new RegExp(
+    `^## \\[${escapeRegExp(currentVersion)}\\].*$`,
+    "m",
+  ).exec(changelog);
+  if (!currentHeading) {
+    throw new Error(`Could not find pi-ai changelog section ${currentVersion}`);
+  }
+  const previousHeading = new RegExp(
+    `^## \\[${escapeRegExp(previousVersion)}\\].*$`,
+    "m",
+  ).exec(changelog.slice(currentHeading.index + currentHeading[0].length));
+  if (!previousHeading) {
+    throw new Error(
+      `Could not find pi-ai changelog section ${previousVersion}`,
+    );
+  }
+  const end =
+    currentHeading.index + currentHeading[0].length + previousHeading.index;
+  return changelog.slice(currentHeading.index, end).trim();
 }
 
 function findPreviousStableRelease(
@@ -276,18 +297,37 @@ function fetchTag(repoDir: string, tag: string): void {
   );
 }
 
-function verifyTagMatchesPackage(
+function resolveReleaseSource(
   repoDir: string,
   tag: string,
   release: PackageRelease,
-): void {
-  if (!release.git_head) return;
+): { sourceCommit: string; tagCommit: string } {
+  fetchTag(repoDir, tag);
   const tagCommit = git(["rev-list", "-n", "1", tag], repoDir).trim();
-  if (tagCommit !== release.git_head) {
+  const sourceCommit = release.git_head ?? tagCommit;
+  if (sourceCommit !== tagCommit) {
+    fetchCommit(repoDir, sourceCommit);
+  }
+  const packageJson = showFile(
+    repoDir,
+    sourceCommit,
+    "packages/ai/package.json",
+  );
+  if (packageJson === null) {
+    throw new Error(`packages/ai/package.json is missing at ${sourceCommit}`);
+  }
+  const sourceVersion = (JSON.parse(packageJson) as { version?: unknown })
+    .version;
+  if (sourceVersion !== release.version) {
     throw new Error(
-      `pi-ai npm ${release.version} gitHead ${release.git_head} does not match ${tag} commit ${tagCommit}`,
+      `pi-ai npm ${release.version} source ${sourceCommit} declares version ${String(sourceVersion)}`,
     );
   }
+  return { sourceCommit, tagCommit };
+}
+
+function fetchCommit(repoDir: string, commit: string): void {
+  git(["fetch", "--filter=blob:none", "origin", commit], repoDir);
 }
 
 function showFile(repoDir: string, tag: string, path: string): string | null {