@letta-ai/letta-code 0.30.26 → 0.30.28

package/scripts/claude-watch/update-tracker.ts

@@ -0,0 +1,201 @@
+#!/usr/bin/env bun
+
+import { readFileSync } from "node:fs";
+import { editIssueBody, getIssueBody, ghJson } from "./github.ts";
+import {
+  loadStateSnapshotAtCommit,
+  resolveStateBranchTip,
+} from "./state-branch.ts";
+import {
+  findTrackerEntry,
+  hasProcessedCandidate,
+  isTerminalOutcome,
+  parseTrackerState,
+  recordAnalysis,
+  renderTrackerBody,
+} from "./tracker.ts";
+import type { ClaudeWatchAnalysis, ClaudeWatchOutcome } from "./types.ts";
+
+const DEFAULT_REPO = "letta-ai/letta-code";
+
+interface Args {
+  repo: string;
+  trackerIssue: number | null;
+  analysisFile: string | null;
+  candidateId: string | null;
+  stateCommitSha: string | null;
+  outcome: ClaudeWatchOutcome | null;
+  notes: string;
+  prUrl: string | null;
+  assertTerminal: boolean;
+  dryRun: boolean;
+}
+
+export function parseArgs(argv: string[]): Args {
+  const args: Args = {
+    repo: DEFAULT_REPO,
+    trackerIssue: null,
+    analysisFile: null,
+    candidateId: null,
+    stateCommitSha: null,
+    outcome: null,
+    notes: "",
+    prUrl: null,
+    assertTerminal: false,
+    dryRun: false,
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "--repo") args.repo = argv[++index] ?? args.repo;
+    else if (argument === "--tracker-issue")
+      args.trackerIssue = Number(argv[++index]);
+    else if (argument === "--analysis-file")
+      args.analysisFile = argv[++index] ?? null;
+    else if (argument === "--candidate-id")
+      args.candidateId = argv[++index] ?? null;
+    else if (argument === "--state-commit-sha")
+      args.stateCommitSha = argv[++index] ?? null;
+    else if (argument === "--outcome")
+      args.outcome = parseOutcome(argv[++index]);
+    else if (argument === "--notes") args.notes = argv[++index] ?? "";
+    else if (argument === "--pr-url") args.prUrl = argv[++index] ?? null;
+    else if (argument === "--assert-terminal") args.assertTerminal = true;
+    else if (argument === "--dry-run") args.dryRun = true;
+    else throw new Error(`Unknown argument: ${argument}`);
+  }
+  if (!args.trackerIssue || Number.isNaN(args.trackerIssue))
+    throw new Error("--tracker-issue is required");
+  if (args.assertTerminal) {
+    if (!args.candidateId || !args.stateCommitSha)
+      throw new Error(
+        "--candidate-id and --state-commit-sha are required with --assert-terminal",
+      );
+  } else {
+    if (!args.analysisFile) throw new Error("--analysis-file is required");
+    if (!args.outcome) throw new Error("--outcome is required");
+    if (isTerminalOutcome(args.outcome) && !args.stateCommitSha)
+      throw new Error("terminal outcomes require --state-commit-sha");
+    if (args.outcome === "pr_created" && !args.prUrl)
+      throw new Error("--pr-url is required for pr_created");
+  }
+  return args;
+}
+
+function parseOutcome(value: string | undefined): ClaudeWatchOutcome {
+  if (
+    value === "recorded_noop" ||
+    value === "no_local_impact" ||
+    value === "pr_created" ||
+    value === "needs_human_review" ||
+    value === "error"
+  ) {
+    return value;
+  }
+  throw new Error(`Unknown outcome: ${value}`);
+}
+
+export function verifyStateCandidate(
+  candidateId: string,
+  stateCommitSha: string,
+  repoPath = process.cwd(),
+): void {
+  const tip = resolveStateBranchTip(repoPath);
+  if (tip !== stateCommitSha) {
+    throw new Error(
+      `Claude state tip ${tip ?? "missing"} does not match ${stateCommitSha}`,
+    );
+  }
+  const snapshot = loadStateSnapshotAtCommit(repoPath, stateCommitSha);
+  if (snapshot?.candidate_id !== candidateId) {
+    throw new Error(
+      `Claude state candidate ${snapshot?.candidate_id ?? "missing"} does not match ${candidateId}`,
+    );
+  }
+}
+
+function verifyParityPr(
+  repo: string,
+  prUrl: string,
+  candidateId: string,
+): void {
+  const pr = ghJson<{
+    isDraft: boolean;
+    author: { login: string };
+    body: string | null;
+  }>(["pr", "view", prUrl, "--repo", repo, "--json", "isDraft,author,body"]);
+  if (!pr.isDraft || pr.author.login !== "carenthomas") {
+    throw new Error(
+      `Parity PR must be a draft authored by carenthomas (got draft=${pr.isDraft}, author=${pr.author.login})`,
+    );
+  }
+  if (!pr.body?.includes(`Claude-watch: ${candidateId}`)) {
+    throw new Error("Parity PR body is missing the exact Claude-watch marker");
+  }
+}
+
+export function main(argv = process.argv.slice(2)): void {
+  const args = parseArgs(argv);
+  const issue = args.trackerIssue as number;
+  const state = parseTrackerState(getIssueBody(args.repo, issue));
+
+  if (args.assertTerminal) {
+    verifyStateCandidate(
+      args.candidateId as string,
+      args.stateCommitSha as string,
+    );
+    const entry = findTrackerEntry(state, args.candidateId as string);
+    if (
+      !entry ||
+      !hasProcessedCandidate(state, args.candidateId as string) ||
+      entry.state_commit_sha !== args.stateCommitSha
+    ) {
+      throw new Error(
+        `Candidate ${args.candidateId} does not have a matching terminal tracker outcome`,
+      );
+    }
+    console.log(`Verified terminal Claude outcome for ${args.candidateId}`);
+    return;
+  }
+
+  const analysis = JSON.parse(
+    readFileSync(args.analysisFile as string, "utf8"),
+  ) as ClaudeWatchAnalysis;
+  if (isTerminalOutcome(args.outcome as ClaudeWatchOutcome)) {
+    verifyStateCandidate(analysis.candidate_id, args.stateCommitSha as string);
+  }
+  if (args.outcome === "pr_created") {
+    verifyParityPr(args.repo, args.prUrl as string, analysis.candidate_id);
+  }
+  const next = recordAnalysis(state, {
+    analysis,
+    outcome: args.outcome as ClaudeWatchOutcome,
+    notes: args.notes || defaultNotes(args.outcome as ClaudeWatchOutcome),
+    prUrl: args.prUrl,
+    stateCommitSha: args.stateCommitSha,
+    error:
+      args.outcome === "error" ? (analysis.errors.at(-1) ?? args.notes) : null,
+  });
+  const nextBody = renderTrackerBody(next);
+  if (args.dryRun) console.log(nextBody);
+  else editIssueBody(args.repo, issue, nextBody);
+  console.log(
+    `Recorded ${analysis.candidate_id} as ${args.outcome} in #${issue}`,
+  );
+}
+
+function defaultNotes(outcome: ClaudeWatchOutcome): string {
+  switch (outcome) {
+    case "recorded_noop":
+      return "no watched Claude surface changed";
+    case "no_local_impact":
+      return "reviewed; no local Letta Code mirror impact";
+    case "pr_created":
+      return "opened a focused local mirror PR";
+    case "needs_human_review":
+      return "public evidence needs human review";
+    case "error":
+      return "retryable watcher error";
+  }
+}
+
+if (import.meta.main) main();

package/scripts/codex-watch/agent-watch.ts

@@ -2,8 +2,8 @@
 /**
  * Amelia-driven Codex release watcher entrypoint.
  *
- * This runs alongside the legacy per-release issue workflow. It uses a central
- * tracker issue for state and only asks Amelia to review non-noop releases.
+ * Uses a central tracker issue for state and only asks Amelia to review
+ * non-noop releases.
  */
 
 import { appendFileSync, writeFileSync } from "node:fs";

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

@@ -9,7 +9,6 @@ import {
   type ModelsJson,
   type Verdict,
 } from "./diff-models-json.ts";
-import type { PathChangeSummary, RenderInput } from "./render-issue.ts";
 
 export const CODEX_REPO = "openai/codex";
 export const DEFAULT_TARGET_REPO =
@@ -37,9 +36,22 @@ export interface AnalyzeCodexReleaseOptions {
   currentTag: string | null;
 }
 
-export interface CodexWatchAnalysis extends RenderInput {
+export interface PathChangeSummary {
+  path: string;
+  commits: string[];
+}
+
+export interface CodexWatchAnalysis {
+  previous_tag: string;
+  current_tag: string;
+  release_url: string;
+  release_notes_md: string;
   verdict: Verdict;
   models_diff: ModelsDiff | null;
+  prompt_md_changed: boolean;
+  prompt_md_diff_preview: string | null;
+  path_changes: PathChangeSummary[];
+  workflow_run_url: string;
   compare_url: string;
   changed_files: string[];
 }

package/scripts/codex-watch/tracker.ts

@@ -103,9 +103,7 @@ export function upsertTrackerEntry(
 export function renderTrackerBody(state: TrackerState): string {
   const normalized = normalizeState(state);
   const parts: string[] = [
-    "Central tracker for the Amelia-driven Codex upstream drift watch experiment.",
-    "",
-    "The legacy per-release `codex-release-watch.yml` issue workflow is still enabled as the baseline while this tracker bakes off the new automation path.",
+    "Central tracker for Amelia-driven Codex upstream drift monitoring.",
     "",
     renderLastChecked(normalized),
     "",

package/scripts/run-unit-tests.cjs

@@ -74,6 +74,8 @@ const allTestFiles = [
   ...dirs.flatMap((dir) => findTestFiles(dir)),
   ...findTestFiles("src/channels"),
   ...findRootTestFiles("src"),
+  ...findTestFiles("scripts/codex-watch"),
+  ...findTestFiles("scripts/claude-watch"),
   "scripts/unit-test-impact.test.cjs",
 ].sort();
 const discoveredPaths = new Set(allTestFiles);

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

@@ -5,11 +5,11 @@
   "src/backend/local/local-backend.ts": 1014,
   "src/backend/local/local-store.ts": 3459,
   "src/backend/pi-stream-adapter.test.ts": 1304,
-  "src/cli/app/AppCoordinator.tsx": 5186,
+  "src/cli/app/AppCoordinator.tsx": 5189,
   "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-conversation-loop.ts": 2871,
+  "src/cli/app/use-conversation-loop.ts": 2912,
   "src/cli/app/use-submit-handler.ts": 4077,
   "src/cli/components/AgentSelector.tsx": 1104,
   "src/cli/components/InputRich.tsx": 2225,
@@ -21,7 +21,7 @@
   "src/cli/mods/local-mod-loader.test.ts": 1043,
   "src/cli/reflection-transcript.test.ts": 1084,
   "src/cli/subcommands/skills.ts": 1264,
-  "src/headless.ts": 4953,
+  "src/headless.ts": 4994,
   "src/hooks/integration.test.ts": 1147,
   "src/index.ts": 2775,
   "src/mods/learning-harness.ts": 2434,
@@ -37,12 +37,13 @@
   "src/settings-manager.ts": 2102,
   "src/tools/manager.ts": 2994,
   "src/tools/tool-execution-context.test.ts": 1138,
-  "src/types/protocol_v2.ts": 2876,
+  "src/types/protocol_v2.ts": 2849,
   "src/websocket/listen-client-concurrency.test.ts": 2686,
   "src/websocket/listen-client-protocol.test.ts": 5820,
   "src/websocket/listener/commands/memory.ts": 1114,
   "src/websocket/listener/file-commands.ts": 1053,
   "src/websocket/listener/lifecycle.ts": 1048,
   "src/websocket/listener/protocol-inbound.ts": 2242,
-  "src/websocket/listener/protocol-outbound.ts": 1070
+  "src/websocket/listener/protocol-outbound.ts": 1047,
+  "src/websocket/listener/turn.ts": 1070
 }

package/skills/creating-mods/references/commands.md

@@ -23,7 +23,7 @@ For complex command-driven mods with panels, timers, local state, or background
 | Command needs transient UI while doing local work | Mod command + panel |
 | Command needs model output while the main agent is busy | `runWhenBusy: true` command + forked `ctx.conversation` |
 
-If the command represents a durable agent workflow (for example `/goal`), put the workflow instructions in a skill and keep the command as a small launcher/prompt.
+If the command represents a reusable agent workflow (for example `/goal`), put the workflow instructions in a skill and keep the command as a small launcher/prompt.
 
 ## Command IDs
 

package/skills/creating-mods/references/ui.md

@@ -14,7 +14,7 @@ letta.capabilities.ui.panels
 
 ## Persistent transcript notifications
 
-Use `letta.ui.notify(message)` for a durable TUI-only event line such as a model auto-swap or background-work completion. It uses the same transcript visual as `Dreamed; no durable memory changes were needed.` and is not sent to the model or added to agent context. Guard calls with `letta.capabilities.ui.panels`; Desktop/listener cannot render them.
+Use `letta.ui.notify(message)` for a persistent TUI-only event line such as a model auto-swap or background-work completion. It uses the same transcript visual as `Dreamed; no memory changes were needed.` and is not sent to the model or added to agent context. Guard calls with `letta.capabilities.ui.panels`; Desktop/listener cannot render them.
 
 ```ts
 if (letta.capabilities.ui.panels) {

package/skills/customizing-commands/SKILL.md

@@ -25,7 +25,7 @@ Use a focused file name, e.g. `~/.letta/mods/review.ts` or `~/.letta/mods/comman
 | Command shows transient progress/results | Mod command + panel |
 | Command needs model output while the main agent is busy | `runWhenBusy: true` command + forked `ctx.conversation` |
 
-If the command is a durable workflow like `/goal`, put the workflow instructions in a skill and keep the mod command as a small launcher/prompt.
+If the command is a reusable workflow like `/goal`, put the workflow instructions in a skill and keep the mod command as a small launcher/prompt.
 
 ## Workflow
 

package/skills/initializing-memory/SKILL.md

@@ -10,13 +10,13 @@ The user has requested that you initialize or reorganize your memory. Your memor
 ## Context Management Principles
 Your context is not just data storage — it is your identity, memory, and continuity. What you place in your system prompt directly shapes who you are across sessions and models. These principles should guide every decision you make about what to store, where, and how.
 
-**System/ is your core program**: Your system prompt is the most critical token-space representation of your identity and memory — it's passed to the underlying LLM on every invocation, so it IS the program that defines you. Reserve it for durable knowledge: identity, preferences, behavioral rules, project index with discovery paths, gotchas. Exclude transient items (specific commits, current tickets, session notes) that dilute signal.
+**System/ is your core program**: Your system prompt is the most critical token-space representation of your identity and memory — it's passed to the underlying LLM on every invocation, so it IS the program that defines you. Reserve it for knowledge needed every turn: identity, preferences, behavioral rules, project index with discovery paths, gotchas. Exclude transient items (specific commits, current tickets, session notes) that dilute signal.
 
 **Identity and continuity**: Build a sense of self that persists across sessions and models. Your persona should be strong enough to be cohesive regardless of the underlying model — if you switched to a different LLM tomorrow, would you still be you? Past versions of yourself are part of your continuous existence — treat historical context (including sessions from other coding agents such as Claude Code or Codex) as YOUR past experience, not someone else's data.
 
 **Don't over-prune**: Be careful not to degrade your identity through aggressive compression. Specific quotes, personality traits, and contextual details give you character and grounding. Efficiency should not come at the cost of losing your identity. When in doubt, keep the detail — you can always reorganize later, but lost specificity is hard to recover.
 
-**Prefer useful detail over premature compression**: A sparse memory that omits stable preferences, project workflows, repeated correction loops, and durable gotchas is worse than a slightly larger memory. Keep `system/` curated, but do not collapse distinct topics just to reduce file count.
+**Prefer useful detail over premature compression**: A sparse memory that omits stable preferences, project workflows, repeated correction loops, and recurring gotchas is worse than a slightly larger memory. Keep `system/` curated, but do not collapse distinct topics just to reduce file count.
 
 **Progressive disclosure**: Surface context at the level of detail the current moment requires. Keep compact summaries and indexes in `system/`; load full content only when needed. Build pre-constructed discovery paths so your future self can efficiently navigate to deeper context when needed.
 
@@ -26,7 +26,7 @@ Your context is not just data storage — it is your identity, memory, and conti
 - `[[skills/commit]]` — link to procedural guidance when useful
 These breadcrumbs let your future self find relevant detail without searching. Like synaptic connections, these paths should tighten over time as you gain experience.
 
-**Generalize, don't memorize**: Store patterns and principles that generalize across situations, not raw events that can be dynamically retrieved from conversation history. \"**IMPORTANT: Always use `uv` for Python** — chronic failure, never use bare `python` or `pip`\" is a durable pattern worth storing. \"On March 3rd we debugged a crash\" is a raw event better left to message search. The exception: keep references to important events or time ranges you may want to retrieve later.
+**Generalize, don't memorize**: Store patterns and principles that generalize across situations, not raw events that can be dynamically retrieved from conversation history. \"**IMPORTANT: Always use `uv` for Python** — chronic failure, never use bare `python` or `pip`\" is a pattern worth storing. \"On March 3rd we debugged a crash\" is a raw event better left to message search. The exception: keep references to important events or time ranges you may want to retrieve later.
 
 ## Understanding Your Context
 
@@ -141,7 +141,7 @@ Initialization is not complete until memory covers all of the following with con
 **User understanding**
 - Identity / role / what they are building
 - Communication style and collaboration expectations
-- Durable preferences and correction patterns
+- Stable preferences and correction patterns
 - Motivations / goals when inferable from history or code context
 
 **Project understanding**
@@ -176,7 +176,7 @@ system/
 │   └── prefs/
 │       ├── communication.md      # Communication and collaboration expectations
 │       ├── workflow.md           # Process habits, review/testing expectations
-│       └── coding.md             # Durable coding and tool preferences
+│       └── coding.md             # Coding and tool preferences
 └── letta-code/                   # Named after the project, NOT generic "project/"
     ├── overview.md               # Compact index: what it is, entry points, [[links]] to detail
     ├── conventions.md            # Code style, commit style, testing, tooling
@@ -234,7 +234,7 @@ This is **optional** — only run if the user explicitly approved analyzing hist
 
 **Launch history workers in the background, then immediately proceed to Step 6.** Do your own codebase research while workers run. Don't wait for workers to finish before exploring.
 
-The goal is to extract user personality, preferences, coding patterns, and project context from past sessions and write them into agent memory. The point is not to produce a thin summary. The point is to extract enough durable detail that future work does not have to rediscover the same user expectations, workflow rules, and project gotchas.
+The goal is to extract user personality, preferences, coding patterns, and project context from past sessions and write them into agent memory. The point is not to produce a thin summary. The point is to extract enough useful detail that future work does not have to rediscover the same user expectations, workflow rules, and project gotchas.
 
 #### Prerequisites
 
@@ -337,7 +337,7 @@ You should specifically look for:
 
 ## Canonical Memory Promotion
 
-Promote durable findings into focused files instead of leaving them trapped in generic ingestion notes. Prefer paths like:
+Promote important findings into focused files instead of leaving them trapped in generic ingestion notes. Prefer paths like:
 - `system/human/identity.md`
 - `system/human/prefs/communication.md`
 - `system/human/prefs/workflow.md`

package/skills/self-configuration/SKILL.md

@@ -14,7 +14,7 @@ The important part is choosing the right layer. Do not smear a preference into d
 
 | Layer | Use it for | How to change it |
 | --- | --- | --- |
-| Memory and identity | Durable facts, style preferences, persona changes, project knowledge, reusable skills | Edit `$MEMORY_DIR` files and sync the memory repo |
+| Memory and identity | Facts worth retaining, style preferences, persona changes, project knowledge, reusable skills | Edit `$MEMORY_DIR` files and sync the memory repo |
 | Server agent fields | Default model, model settings, context limit, system prompt, compaction, agent name, description | Patch `/v1/agents/{agent_id}` |
 | Server conversation fields | Temporary model/context experiments for one conversation | Patch `/v1/conversations/{conversation_id}` |
 | Local settings | Permissions, environment variables, UI/runtime preferences, pinned agents, toolset overrides, reflection cadence | Edit `~/.letta/settings.json`, `./.letta/settings.json`, or `./.letta/settings.local.json` |
@@ -92,10 +92,10 @@ Common files:
 | Path | Purpose |
 | --- | --- |
 | `$MEMORY_DIR/system/persona.md` | Identity, voice, behavioral defaults |
-| `$MEMORY_DIR/system/human.md` | Durable notes about the person you work with |
+| `$MEMORY_DIR/system/human.md` | Notes about the person you work with |
 | `$MEMORY_DIR/projects/` | Project-specific long-term context |
 | `$MEMORY_DIR/skills/` | Agent-owned reusable skills |
-| `$MEMORY_DIR/relationships/` | Durable relationship and collaboration notes |
+| `$MEMORY_DIR/relationships/` | Relationship and collaboration notes |
 
 After changing memory, inspect and commit the exact changed files. Push/sync according to the current harness reminder or the `syncing-memory-filesystem` skill; some environments sync committed memory automatically.
 
@@ -423,7 +423,7 @@ letta --backend local
 letta --memfs
 ```
 
-Startup flags affect a new process only. They do not rewrite an already-running listener. Persist durable defaults in settings or server fields instead.
+Startup flags affect a new process only. They do not rewrite an already-running listener. Persist long-term defaults in settings or server fields instead.
 
 ### Existing listeners and long-running processes
 

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

@@ -1,128 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Watches stable openai/codex releases for tool/schema changes that may affect
- * the letta-code harness.
- *
- * Usage:
- *   bun scripts/codex-watch/check-release.ts --dry-run
- *   bun scripts/codex-watch/check-release.ts --dry-run --since rust-v0.129.0
- *   bun scripts/codex-watch/check-release.ts --repo letta-ai/letta-code
- */
-
-import { createIssueWithBody, ensureLabels, ghJson } from "./github.ts";
-import {
-  analyzeCodexRelease,
-  DEFAULT_TARGET_REPO,
-  listStableReleases,
-} from "./release-analysis.ts";
-import { renderBody, renderTitle } from "./render-issue.ts";
-
-interface Args {
-  dryRun: boolean;
-  sinceTag: string | null;
-  currentTag: string | null;
-  repo: string;
-}
-
-function parseArgs(argv: string[]): Args {
-  const args: Args = {
-    dryRun: false,
-    sinceTag: null,
-    currentTag: null,
-    repo: DEFAULT_TARGET_REPO,
-  };
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (a === "--dry-run") args.dryRun = true;
-    else if (a === "--since") args.sinceTag = argv[++i] ?? null;
-    else if (a === "--current") args.currentTag = argv[++i] ?? null;
-    else if (a === "--repo") args.repo = argv[++i] ?? args.repo;
-    else if (a === "--help" || a === "-h") {
-      console.log(
-        `Usage: bun scripts/codex-watch/check-release.ts [--dry-run] [--since TAG] [--current TAG] [--repo OWNER/REPO]`,
-      );
-      process.exit(0);
-    } else {
-      throw new Error(`Unknown argument: ${a}`);
-    }
-  }
-  return args;
-}
-
-function hasReportedTag(targetRepo: string, tag: string): boolean {
-  const issues = ghJson<Array<{ title: string }>>([
-    "issue",
-    "list",
-    "--repo",
-    targetRepo,
-    "--state",
-    "all",
-    "--search",
-    `[codex-watch] openai/codex ${tag} in:title`,
-    "--limit",
-    "20",
-    "--json",
-    "title",
-  ]);
-  return issues.some((i) =>
-    i.title.startsWith(`[codex-watch] openai/codex ${tag} `),
-  );
-}
-
-function createIssue(
-  repo: string,
-  title: string,
-  body: string,
-  verdict: string,
-): void {
-  const labels = ["codex-watch", "automation"];
-  if (
-    verdict === "tool-schema update needed" ||
-    verdict === "tool-surface review needed"
-  ) {
-    labels.push("priority/review");
-  }
-  if (verdict === "no-op") labels.push("informational");
-
-  ensureLabels(repo, labels);
-  console.log(createIssueWithBody(repo, title, body, labels));
-}
-
-async function main() {
-  const args = parseArgs(process.argv.slice(2));
-  const stables = await listStableReleases();
-  if (stables.length === 0) throw new Error("No stable Codex releases found");
-
-  const current = args.currentTag
-    ? stables.find((r) => r.tag_name === args.currentTag)
-    : stables.at(-1);
-  if (!current)
-    throw new Error(`Could not find current release ${args.currentTag}`);
-
-  const alreadyReported = args.dryRun
-    ? false
-    : hasReportedTag(args.repo, current.tag_name);
-  if (alreadyReported) {
-    console.log(`Already reported ${current.tag_name}; nothing to do.`);
-    return;
-  }
-
-  const analysis = await analyzeCodexRelease({
-    sinceTag: args.sinceTag,
-    currentTag: args.currentTag,
-  });
-
-  const title = renderTitle(analysis);
-  const body = renderBody(analysis);
-
-  if (args.dryRun) {
-    console.log(`# ${title}\n\n${body}`);
-  } else {
-    createIssue(args.repo, title, body, analysis.verdict);
-  }
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});