@letta-ai/letta-code 0.30.31 → 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,37 +21,31 @@ 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("Could not find terminal release rust-v0.0.9");
+    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,17 +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 {
@@ -227,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,
@@ -37,7 +37,7 @@ function analysis(
 
 function withoutAuditCursor(body: string): string {
   return body
-    .replace(/  "audit_cursor_tag": (?:null|"[^"]+"),\n/, "")
+    .replace(/ {2}"audit_cursor_tag": (?:null|"[^"]+"),\n/, "")
     .replace('  "audit_cursor_validated": true,\n', "");
 }
 
@@ -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,
@@ -198,11 +198,7 @@ describe("tracker state", () => {
 
     const body = renderTrackerBody(state);
     expect(
-      hasProcessedRange(
-        parseTrackerState(body),
-        "rust-v0.1.0",
-        "rust-v0.2.0",
-      ),
+      hasProcessedRange(parseTrackerState(body), "rust-v0.1.0", "rust-v0.2.0"),
     ).toBe(true);
     expect(body).toContain("_No actionable releases recorded yet._");
     expect(body).toContain("no watched changes");
@@ -215,23 +211,16 @@ describe("tracker state", () => {
     );
     state = upsertTrackerEntry(state, entry(2, "error"));
 
-    expect(
-      hasProcessedRange(state, "rust-v0.1.0", "rust-v0.2.0"),
-    ).toBe(false);
+    expect(hasProcessedRange(state, "rust-v0.1.0", "rust-v0.2.0")).toBe(false);
     expect(getCodexAuditCursorTag(state)).toBe("rust-v0.1.0");
 
     state = upsertTrackerEntry(state, entry(2, "no_local_impact"));
-    expect(
-      hasProcessedRange(state, "rust-v0.1.0", "rust-v0.2.0"),
-    ).toBe(true);
+    expect(hasProcessedRange(state, "rust-v0.1.0", "rust-v0.2.0")).toBe(true);
     expect(getCodexAuditCursorTag(state)).toBe("rust-v0.2.0");
   });
 
   test("uses an errored release baseline when no terminal entry exists", () => {
-    const state = upsertTrackerEntry(
-      emptyTrackerState(),
-      entry(2, "error"),
-    );
+    const state = upsertTrackerEntry(emptyTrackerState(), entry(2, "error"));
 
     expect(getCodexAuditCursorTag(state)).toBe("rust-v0.1.0");
   });
@@ -261,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,
@@ -279,17 +268,12 @@ describe("tracker state", () => {
     expect(getCodexAuditCursorTag(state)).toBe("rust-v0.1.0");
     expect(
       getCodexAuditCursorTag(
-        advanceCodexAuditCursor(
-          state,
-          "rust-v0.1.0",
-          "rust-v0.5.0",
-          false,
-        ),
+        advanceCodexAuditCursor(state, "rust-v0.1.0", "rust-v0.5.0", false),
       ),
     ).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"),
@@ -298,12 +282,7 @@ describe("tracker state", () => {
     state = upsertTrackerEntry(state, entry(2, "no_local_impact"));
 
     expect(getCodexAuditCursorTag(state)).toBe("rust-v0.2.0");
-    state = advanceCodexAuditCursor(
-      state,
-      "rust-v0.2.0",
-      "rust-v0.3.0",
-      true,
-    );
+    state = advanceCodexAuditCursor(state, "rust-v0.2.0", "rust-v0.3.0", true);
     expect(getCodexAuditCursorTag(state)).toBe("rust-v0.3.0");
   });
 

package/scripts/codex-watch/tracker.ts

@@ -119,9 +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}`,
@@ -135,35 +135,39 @@ export function recordAnalysis(
   options: RecordAnalysisOptions,
 ): TrackerState {
   const processedAt = options.processedAt ?? new Date().toISOString();
-  return upsertTrackerEntry(state, {
-    tag: options.analysis.current_tag,
-    previous_tag: options.analysis.previous_tag,
-    verdict: options.analysis.verdict,
-    outcome: options.outcome,
-    pr_url: options.prUrl ?? null,
-    notes: options.notes,
-    processed_at: processedAt,
-    compare_url: options.analysis.compare_url,
-    workflow_run_url: options.analysis.workflow_run_url,
-  }, options.analysis.is_adjacent_release);
+  return upsertTrackerEntry(
+    state,
+    {
+      tag: options.analysis.current_tag,
+      previous_tag: options.analysis.previous_tag,
+      verdict: options.analysis.verdict,
+      outcome: options.outcome,
+      pr_url: options.prUrl ?? null,
+      notes: options.notes,
+      processed_at: processedAt,
+      compare_url: options.analysis.compare_url,
+      workflow_run_url: options.analysis.workflow_run_url,
+    },
+    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)
   ) {
@@ -179,7 +183,10 @@ export function upsertTrackerEntry(
     ),
   ];
   let processed = candidates.slice(0, HIDDEN_STATE_LIMIT);
-  if (auditCursorTag !== null && !isSupportedAuditCursor(processed, auditCursorTag)) {
+  if (
+    auditCursorTag !== null &&
+    !isSupportedAuditCursor(processed, auditCursorTag)
+  ) {
     const support = candidates.find((candidate) =>
       isAuditCursorSupportEntry(candidate, auditCursorTag),
     );
@@ -276,7 +283,10 @@ function escapeTable(value: string): string {
 
 function normalizeState(value: unknown): TrackerState {
   if (!isRecord(value)) throw new TypeError("tracker state must be an object");
-  if (!Array.isArray(value.processed) || !value.processed.every(isTrackerEntry)) {
+  if (
+    !Array.isArray(value.processed) ||
+    !value.processed.every(isTrackerEntry)
+  ) {
     throw new TypeError("tracker processed entries are invalid");
   }
   if (
@@ -346,9 +356,7 @@ function isSupportedAuditCursor(
   processed: TrackerEntry[],
   cursorTag: string,
 ): boolean {
-  return processed.some((entry) =>
-    isAuditCursorSupportEntry(entry, cursorTag),
-  );
+  return processed.some((entry) => isAuditCursorSupportEntry(entry, cursorTag));
 }
 
 function isAuditCursorSupportEntry(

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",
     );
   });