@letta-ai/letta-code 0.31.6 → 0.31.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.31.6",
+  "version": "0.31.8",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "packageManager": "bun@1.3.10",
@@ -22,6 +22,8 @@
     "dist/app-server-client.cjs.map",
     "dist/memory-confinement.js",
     "dist/memory-confinement.js.map",
+    "dist/memory-constraints.js",
+    "dist/memory-constraints.js.map",
     "dist/mcp-client.js",
     "dist/mcp-client.js.map",
     "dist/agent-presets.js",
@@ -58,6 +60,11 @@
       "import": "./dist/memory-confinement.js",
       "default": "./dist/memory-confinement.js"
     },
+    "./memory-constraints": {
+      "types": "./dist/types/memory-constraints.d.ts",
+      "import": "./dist/memory-constraints.js",
+      "default": "./dist/memory-constraints.js"
+    },
     "./mcp-client": {
       "types": "./dist/types/mcp-client.d.ts",
       "import": "./dist/mcp-client.js",
@@ -211,6 +218,9 @@
       "memory-confinement": [
         "./dist/types/memory-confinement.d.ts"
       ],
+      "memory-constraints": [
+        "./dist/types/memory-constraints.d.ts"
+      ],
       "mcp-client": [
         "./dist/types/mcp-client.d.ts"
       ],

package/scripts/agent-watch/verify-pr-identity.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, test } from "bun:test";
+import {
+  enforceWatcherPrIdentity,
+  parseArgs,
+  type WatcherPullRequest,
+} from "./verify-pr-identity.ts";
+
+const marker = "Pi-ai-watch: 1.0.0...1.0.1";
+
+function pullRequest(
+  overrides: Partial<WatcherPullRequest> = {},
+): WatcherPullRequest {
+  return {
+    author: { login: "amelia-letta" },
+    body: marker,
+    isDraft: true,
+    number: 123,
+    url: "https://github.com/letta-ai/letta-code/pull/123",
+    ...overrides,
+  };
+}
+
+function enforce(
+  pullRequests: WatcherPullRequest[],
+  closed: string[] = [],
+): WatcherPullRequest | null {
+  return enforceWatcherPrIdentity({
+    repo: "letta-ai/letta-code",
+    marker,
+    expectedLogin: "amelia-letta",
+    pullRequests,
+    closePullRequest: (candidate) => closed.push(candidate.url),
+  });
+}
+
+describe("enforceWatcherPrIdentity", () => {
+  test("returns the matching Amelia draft PR", () => {
+    expect(enforce([pullRequest()])?.number).toBe(123);
+  });
+
+  test("ignores unrelated open PRs", () => {
+    expect(enforce([pullRequest({ body: "unrelated" })])).toBeNull();
+  });
+
+  test("closes and rejects a PR from the wrong author", () => {
+    const closed: string[] = [];
+    expect(() =>
+      enforce([pullRequest({ author: { login: "carenthomas" } })], closed),
+    ).toThrow("author=carenthomas");
+    expect(closed).toEqual(["https://github.com/letta-ai/letta-code/pull/123"]);
+  });
+
+  test("closes and rejects a ready PR", () => {
+    const closed: string[] = [];
+    expect(() => enforce([pullRequest({ isDraft: false })], closed)).toThrow(
+      "draft=false",
+    );
+    expect(closed).toHaveLength(1);
+  });
+
+  test("rejects duplicate valid PRs", () => {
+    expect(() =>
+      enforce([
+        pullRequest(),
+        pullRequest({
+          number: 124,
+          url: "https://github.com/letta-ai/letta-code/pull/124",
+        }),
+      ]),
+    ).toThrow("Multiple open watcher PRs");
+  });
+});
+
+describe("parseArgs", () => {
+  test("requires every identity input", () => {
+    expect(() => parseArgs(["--repo", "letta-ai/letta-code"])).toThrow(
+      "--marker is required",
+    );
+  });
+
+  test("parses a complete invocation", () => {
+    expect(
+      parseArgs([
+        "--repo",
+        "letta-ai/letta-code",
+        "--marker",
+        marker,
+        "--expected-login",
+        "amelia-letta",
+      ]),
+    ).toEqual({
+      repo: "letta-ai/letta-code",
+      marker,
+      expectedLogin: "amelia-letta",
+    });
+  });
+});

package/scripts/agent-watch/verify-pr-identity.ts

@@ -0,0 +1,119 @@
+#!/usr/bin/env bun
+
+import { spawnSync } from "node:child_process";
+
+export interface WatcherPullRequest {
+  author: { login: string } | null;
+  body: string | null;
+  isDraft: boolean;
+  number: number;
+  url: string;
+}
+
+interface Args {
+  expectedLogin: string;
+  marker: string;
+  repo: string;
+}
+
+interface EnforceOptions extends Args {
+  closePullRequest: (pullRequest: WatcherPullRequest) => void;
+  pullRequests: WatcherPullRequest[];
+}
+
+export function enforceWatcherPrIdentity(
+  options: EnforceOptions,
+): WatcherPullRequest | null {
+  const matches = options.pullRequests.filter((pullRequest) =>
+    pullRequest.body?.includes(options.marker),
+  );
+  const invalid = matches.filter(
+    (pullRequest) =>
+      pullRequest.author?.login !== options.expectedLogin ||
+      !pullRequest.isDraft,
+  );
+
+  for (const pullRequest of invalid) options.closePullRequest(pullRequest);
+
+  if (invalid.length > 0) {
+    const details = invalid
+      .map(
+        (pullRequest) =>
+          `${pullRequest.url} (author=${pullRequest.author?.login ?? "unknown"}, draft=${pullRequest.isDraft})`,
+      )
+      .join(", ");
+    throw new Error(
+      `Closed watcher PRs that did not match author=${options.expectedLogin} and draft=true: ${details}`,
+    );
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `Multiple open watcher PRs contain marker ${JSON.stringify(options.marker)}`,
+    );
+  }
+  return matches[0] ?? null;
+}
+
+export function parseArgs(argv: string[]): Args {
+  let repo = "";
+  let marker = "";
+  let expectedLogin = "";
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "--repo") repo = argv[++index] ?? "";
+    else if (argument === "--marker") marker = argv[++index] ?? "";
+    else if (argument === "--expected-login") {
+      expectedLogin = argv[++index] ?? "";
+    } else {
+      throw new Error(`Unknown argument: ${argument}`);
+    }
+  }
+  if (!/^[^/]+\/[^/]+$/.test(repo)) throw new Error("--repo is required");
+  if (!marker) throw new Error("--marker is required");
+  if (!expectedLogin) throw new Error("--expected-login is required");
+  return { repo, marker, expectedLogin };
+}
+
+function runGh(args: string[]): string {
+  const result = spawnSync("gh", args, {
+    encoding: "utf8",
+    maxBuffer: 50 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (result.status !== 0) {
+    throw new Error(`gh ${args.join(" ")} failed:\n${result.stderr}`);
+  }
+  return result.stdout;
+}
+
+function main(): void {
+  const args = parseArgs(process.argv.slice(2));
+  const pullRequests = JSON.parse(
+    runGh([
+      "pr",
+      "list",
+      "--repo",
+      args.repo,
+      "--state",
+      "open",
+      "--limit",
+      "1000",
+      "--json",
+      "author,body,isDraft,number,url",
+    ]),
+  ) as WatcherPullRequest[];
+  const verified = enforceWatcherPrIdentity({
+    ...args,
+    pullRequests,
+    closePullRequest: (pullRequest) => {
+      runGh(["pr", "close", pullRequest.url, "--repo", args.repo]);
+    },
+  });
+  console.log(
+    verified
+      ? `Verified Amelia draft PR: ${verified.url}`
+      : `No open PR contains marker ${JSON.stringify(args.marker)}`,
+  );
+}
+
+if (import.meta.main) main();

package/scripts/builtin-skills-watch/aggregate-results.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 /** Validates a daily skill-review batch and updates the tracker once. */
 
-import { existsSync, readFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import {
   type BuiltinSkillWatchAnalysis,
@@ -9,6 +9,10 @@ import {
   DEFAULT_TARGET_REPO,
 } from "./analysis.ts";
 import { createIssueComment, editIssueBody } from "./github.ts";
+import {
+  discoverReviewArtifacts,
+  formatFailureReceipt,
+} from "./result-artifacts.ts";
 import {
   hasTerminalCandidate,
   parseTrackerState,
@@ -103,6 +107,7 @@ function main(): void {
   let state = parseTrackerState(original.body);
   let failed = false;
   const outcomes: ValidatedOutcome[] = [];
+  const artifacts = discoverReviewArtifacts(args.resultsDir as string);
 
   for (const candidate of manifest.candidates) {
     const analysisPath = join(
@@ -130,14 +135,14 @@ function main(): void {
     analysis.workflow_run_url = workflowRunUrl(pending.workflow_run_id);
     assertAnalysisIdentity(received, analysis);
 
-    const resultPath = join(
-      args.resultsDir as string,
-      `builtin-skill-result-${received.skill}`,
-      "result.json",
-    );
+    const resultPath = artifacts.results.get(received.candidate_id);
     try {
-      if (!existsSync(resultPath)) {
-        throw new Error("Amelia result artifact is missing");
+      if (!resultPath) {
+        const receipt = artifacts.failures.get(received.candidate_id);
+        if (receipt) throw new Error(formatFailureReceipt(receipt));
+        throw new Error(
+          `Amelia result artifact is missing for ${received.candidate_id}`,
+        );
       }
       const result = readReviewResult(resultPath, analysis);
       if (result.pr_url) {

package/scripts/builtin-skills-watch/evidence.test.ts

@@ -29,6 +29,27 @@ describe("review evidence", () => {
     expect(digestReviewEvidence(evidence)).toMatch(/^[a-f0-9]{64}$/);
   });
 
+  test("accepts RFC 3339 UTC timestamps without milliseconds", () => {
+    expect(() =>
+      parseReviewEvidence({
+        schema_version: 1,
+        candidate_id: "candidate",
+        skill: "creating-skills",
+        sources: [
+          {
+            locator: "src/skills/builtin/creating-skills/SKILL.md",
+            revision: "a".repeat(40),
+            content_digest: null,
+            retrieved_at: "2026-08-26T00:00:00Z",
+            excerpt: "current source",
+            claims: ["checked current source"],
+          },
+        ],
+        probes: [],
+      }),
+    ).not.toThrow();
+  });
+
   test("requires at least one source", () => {
     expect(() =>
       parseReviewEvidence({
@@ -38,7 +59,7 @@ describe("review evidence", () => {
         sources: [],
         probes: [],
       }),
-    ).toThrow("sources are invalid");
+    ).toThrow("between 1 and 5 sources");
   });
 
   test("rejects malformed digests and timestamps", () => {
@@ -59,28 +80,51 @@ describe("review evidence", () => {
         ],
         probes: [],
       }),
-    ).toThrow("sources are invalid");
+    ).toThrow("content_digest is invalid");
   });
 
-  test("rejects evidence too large for the tracker", () => {
+  test("accepts production-sized evidence larger than the old tracker limit", () => {
+    const evidence = parseReviewEvidence({
+      schema_version: 1,
+      candidate_id: "candidate",
+      skill: "creating-skills",
+      sources: Array.from({ length: 5 }, (_, index) => ({
+        locator: `https://docs.letta.com/source-${index}`,
+        revision: "a".repeat(40),
+        content_digest: "b".repeat(64),
+        retrieved_at: "2026-08-26T00:00:00.000Z",
+        excerpt: "q".repeat(300),
+        claims: Array.from({ length: 5 }, () => "z".repeat(300)),
+      })),
+      probes: [],
+    });
+
+    expect(Buffer.byteLength(JSON.stringify(evidence), "utf8")).toBeGreaterThan(
+      650,
+    );
+  });
+
+  test("still rejects evidence larger than an issue comment can safely hold", () => {
     expect(() =>
       parseReviewEvidence({
         schema_version: 1,
         candidate_id: "candidate",
         skill: "creating-skills",
-        sources: [
-          {
-            locator: "x".repeat(500),
-            revision: "y".repeat(300),
-            content_digest: null,
-            retrieved_at: "2026-08-26T00:00:00.000Z",
-            excerpt: "q".repeat(300),
-            claims: ["z".repeat(500)],
-          },
-        ],
-        probes: [],
+        sources: Array.from({ length: 5 }, (_, index) => ({
+          locator: `https://docs.letta.com/${"x".repeat(450)}-${index}`,
+          revision: "y".repeat(300),
+          content_digest: null,
+          retrieved_at: "2026-08-26T00:00:00.000Z",
+          excerpt: "q".repeat(300),
+          claims: Array.from({ length: 5 }, () => "z".repeat(500)),
+        })),
+        probes: Array.from({ length: 5 }, () => ({
+          command: "c".repeat(500),
+          result_digest: "d".repeat(64),
+          summary: "s".repeat(500),
+        })),
       }),
-    ).toThrow("exceeds 650 bytes");
+    ).toThrow("exceeds 16384 bytes");
   });
 
   test("requires a revision or digest and rejects unknown fields", () => {
@@ -100,7 +144,7 @@ describe("review evidence", () => {
         sources: [source],
         probes: [],
       }),
-    ).toThrow("sources are invalid");
+    ).toThrow("requires a revision or content_digest");
     expect(() =>
       parseReviewEvidence({
         schema_version: 1,
@@ -109,6 +153,6 @@ describe("review evidence", () => {
         sources: [{ ...source, content_digest: "a".repeat(64), secret: "no" }],
         probes: [],
       }),
-    ).toThrow("sources are invalid");
+    ).toThrow("unknown or missing fields");
   });
 });

package/scripts/builtin-skills-watch/evidence.ts

@@ -3,7 +3,7 @@ import { createHash } from "node:crypto";
 const MAX_SOURCES = 5;
 const MAX_PROBES = 5;
 const MAX_CLAIMS_PER_SOURCE = 5;
-const MAX_SERIALIZED_BYTES = 650;
+const MAX_SERIALIZED_BYTES = 16 * 1024;
 
 export interface EvidenceSource {
   locator: string;
@@ -51,29 +51,24 @@ export function parseReviewEvidence(value: unknown): ReviewEvidence {
   if (
     !Array.isArray(value.sources) ||
     value.sources.length === 0 ||
-    value.sources.length > MAX_SOURCES ||
-    !value.sources.every(isEvidenceSource)
+    value.sources.length > MAX_SOURCES
   ) {
-    throw new TypeError("review evidence sources are invalid");
+    throw new TypeError("review evidence must include between 1 and 5 sources");
   }
-  if (
-    !Array.isArray(value.probes) ||
-    value.probes.length > MAX_PROBES ||
-    !value.probes.every(isEvidenceProbe)
-  ) {
-    throw new TypeError("review evidence probes are invalid");
+  if (!Array.isArray(value.probes) || value.probes.length > MAX_PROBES) {
+    throw new TypeError("review evidence must include at most 5 probes");
   }
   const evidence: ReviewEvidence = {
     schema_version: 1,
     candidate_id: value.candidate_id,
     skill: value.skill,
-    sources: value.sources,
-    probes: value.probes,
+    sources: value.sources.map(parseEvidenceSource),
+    probes: value.probes.map(parseEvidenceProbe),
   };
   if (
     Buffer.byteLength(JSON.stringify(evidence), "utf8") > MAX_SERIALIZED_BYTES
   ) {
-    throw new TypeError("review evidence exceeds 650 bytes");
+    throw new TypeError("review evidence exceeds 16384 bytes");
   }
   return evidence;
 }
@@ -82,44 +77,77 @@ export function digestReviewEvidence(evidence: ReviewEvidence): string {
   return createHash("sha256").update(JSON.stringify(evidence)).digest("hex");
 }
 
-function isEvidenceSource(value: unknown): value is EvidenceSource {
-  return (
-    isRecord(value) &&
-    hasExactKeys(value, [
+function parseEvidenceSource(value: unknown, index: number): EvidenceSource {
+  const description = `review evidence source ${index + 1}`;
+  if (
+    !isRecord(value) ||
+    !hasExactKeys(value, [
       "locator",
       "revision",
       "content_digest",
       "retrieved_at",
       "excerpt",
       "claims",
-    ]) &&
-    isBoundedString(value.locator, 500) &&
-    (value.revision === null || isBoundedString(value.revision, 300)) &&
-    (value.content_digest === null || isDigest(value.content_digest)) &&
-    (value.revision !== null || value.content_digest !== null) &&
-    isIsoTimestamp(value.retrieved_at) &&
-    isBoundedString(value.excerpt, 300) &&
-    Array.isArray(value.claims) &&
-    value.claims.length > 0 &&
-    value.claims.length <= MAX_CLAIMS_PER_SOURCE &&
-    value.claims.every((claim) => isBoundedString(claim, 500))
-  );
+    ])
+  ) {
+    throw new TypeError(`${description} has unknown or missing fields`);
+  }
+  if (!isBoundedString(value.locator, 500)) {
+    throw new TypeError(`${description} locator is invalid`);
+  }
+  if (value.revision !== null && !isBoundedString(value.revision, 300)) {
+    throw new TypeError(`${description} revision is invalid`);
+  }
+  if (value.content_digest !== null && !isDigest(value.content_digest)) {
+    throw new TypeError(`${description} content_digest is invalid`);
+  }
+  if (value.revision === null && value.content_digest === null) {
+    throw new TypeError(`${description} requires a revision or content_digest`);
+  }
+  if (!isIsoTimestamp(value.retrieved_at)) {
+    throw new TypeError(`${description} retrieved_at is not an ISO timestamp`);
+  }
+  if (!isBoundedString(value.excerpt, 300)) {
+    throw new TypeError(`${description} excerpt is invalid`);
+  }
+  if (
+    !Array.isArray(value.claims) ||
+    value.claims.length === 0 ||
+    value.claims.length > MAX_CLAIMS_PER_SOURCE ||
+    !value.claims.every((claim) => isBoundedString(claim, 500))
+  ) {
+    throw new TypeError(`${description} claims are invalid`);
+  }
+  return value as unknown as EvidenceSource;
 }
 
-function isEvidenceProbe(value: unknown): value is EvidenceProbe {
-  return (
-    isRecord(value) &&
-    hasExactKeys(value, ["command", "result_digest", "summary"]) &&
-    isBoundedString(value.command, 500) &&
-    isDigest(value.result_digest) &&
-    isBoundedString(value.summary, 500)
-  );
+function parseEvidenceProbe(value: unknown, index: number): EvidenceProbe {
+  const description = `review evidence probe ${index + 1}`;
+  if (
+    !isRecord(value) ||
+    !hasExactKeys(value, ["command", "result_digest", "summary"])
+  ) {
+    throw new TypeError(`${description} has unknown or missing fields`);
+  }
+  if (!isBoundedString(value.command, 500)) {
+    throw new TypeError(`${description} command is invalid`);
+  }
+  if (!isDigest(value.result_digest)) {
+    throw new TypeError(`${description} result_digest is invalid`);
+  }
+  if (!isBoundedString(value.summary, 500)) {
+    throw new TypeError(`${description} summary is invalid`);
+  }
+  return value as unknown as EvidenceProbe;
 }
 
 function isIsoTimestamp(value: unknown): value is string {
   if (typeof value !== "string") return false;
   const parsed = new Date(value);
-  return !Number.isNaN(parsed.getTime()) && parsed.toISOString() === value;
+  return (
+    !Number.isNaN(parsed.getTime()) &&
+    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/.test(value)
+  );
 }
 
 function isDigest(value: unknown): value is string {