screenshot and worktree fixes

Author: robertherber

scripts/eternity-loop/bootstrap.ts

@@ -37,27 +37,36 @@ export async function bootstrap(args: string[]): Promise<void> {
 
   // Remove existing worktree
   try {
-    await $`git worktree remove --force ${worktreePath}`.quiet();
+    await $`git -C ${repoRoot} worktree remove --force --force ${worktreePath}`.quiet();
   } catch {
-    try {
-      await $`rm -rf ${worktreePath}`.quiet();
-    } catch {
-      // Already gone
-    }
+    // Continue with hard cleanup below.
+  }
+
+  // Clear stale worktree metadata and path left by interrupted runs.
+  try {
+    await $`git -C ${repoRoot} worktree prune --expire now`.quiet();
+  } catch {
+    // Best effort
+  }
+
+  try {
+    await $`rm -rf ${worktreePath}`.quiet();
+  } catch {
+    // Already gone
   }
 
   // Create fresh worktree detached on origin/main
   await $`mkdir -p ${dirname(worktreePath)}`;
-  await $`git fetch origin`.quiet();
+  await $`git -C ${repoRoot} fetch origin`.quiet();
 
   let mainRef = "origin/main";
   try {
-    await $`git rev-parse --verify origin/main`.quiet();
+    await $`git -C ${repoRoot} rev-parse --verify origin/main`.quiet();
   } catch {
     mainRef = "origin/master";
   }
 
-  await $`git worktree add ${worktreePath} --detach ${mainRef}`;
+  await $`git -C ${repoRoot} worktree add --force ${worktreePath} --detach ${mainRef}`;
 
   spinner.stop();
 

scripts/eternity-loop/eternity-loop-prompts/ralph-claude-md.md

@@ -81,3 +81,4 @@ If there are still stories with `passes: false`, end your response normally (ano
 - Keep CI green
 - Do NOT switch branches - stay on the current branch at all times
 - Read the Codebase Patterns section in progress.txt before starting
+- Never commit ralph files

scripts/eternity-loop/git.ts

@@ -21,22 +21,13 @@ export async function ensureMainBranch(workDir: string): Promise<void> {
 export async function checkoutBranch(workDir: string, branch: string): Promise<void> {
   await $`git -C ${workDir} fetch origin`.quiet();
 
-  // Try checking out existing branch first, create from remote if available
+  // Force-create (or reset) the local branch to match the remote, then check it out.
+  // Using -B avoids errors when the branch already exists (e.g. checked out in another worktree).
   try {
-    await $`git -C ${workDir} checkout ${branch}`.quiet();
+    await $`git -C ${workDir} checkout -B ${branch} origin/${branch}`.quiet();
   } catch {
-    try {
-      await $`git -C ${workDir} checkout -b ${branch} origin/${branch}`.quiet();
-    } catch {
-      await $`git -C ${workDir} checkout -b ${branch}`;
-    }
-  }
-
-  // Pull latest from origin if the remote branch exists
-  try {
-    await $`git -C ${workDir} reset --hard origin/${branch}`.quiet();
-  } catch {
-    // Remote branch may not exist yet for new branches
+    // Remote branch doesn't exist yet — create a new local branch
+    await $`git -C ${workDir} checkout -B ${branch}`.quiet();
   }
 }
 
@@ -52,8 +43,9 @@ export async function getCurrentBranch(workDir: string): Promise<string> {
 
 export async function getLatestCommitDate(workDir: string, branch?: string): Promise<string> {
   const ref = branch ? `origin/${branch}` : "HEAD";
-  const result = await $`git -C ${workDir} log -1 --format=%ad --date=format-local:%Y-%m-%dT%H:%M:%SZ ${ref}`.text();
-  return result.trim();
+  const result = await $`git -C ${workDir} log -1 --format=%ct ${ref}`.text();
+  const epochSeconds = Number.parseInt(result.trim(), 10);
+  return new Date(epochSeconds * 1000).toISOString();
 }
 
 export async function getLatestCommitMessage(workDir: string, branch?: string): Promise<string> {

scripts/eternity-loop/github/pr.ts

@@ -1,6 +1,8 @@
 import type { Octokit } from "@octokit/rest";
 import { graphql } from "@octokit/graphql";
 import { join, basename } from "node:path";
+import { logDebug } from "../logger";
+import { log } from "node:console";
 
 export async function findPrByBranch(
   octokit: Octokit,
@@ -235,6 +237,8 @@ export async function getPrComments(
   const allComments = await fetchAllPrComments(octokit, owner, repo, prNumber);
   const humanComments = allComments.filter((c) => !c.isBot);
 
+  logDebug(`[allComments] Fetched ${allComments.length} total comments (${humanComments.length} human) for PR #${prNumber}, latest cutoff: ${cutoffDate}, latest comment date: ${humanComments.map(c => c.createdAt).sort().reverse()}`);
+
   if (cutoffDate) {
     const cutoff = new Date(cutoffDate);
     const newComments = humanComments.filter((c) => new Date(c.createdAt) > cutoff);
@@ -253,6 +257,7 @@ export async function checkForNewHumanComments(
   latestCommitDate: string,
 ): Promise<boolean> {
   const { new: newComments } = await getPrComments(octokit, owner, repo, prNumber, latestCommitDate);
+  logDebug(`[checkForNewHumanComments] Found ${newComments.length} new human comment(s) since ${latestCommitDate}`);
   return newComments.length > 0;
 }
 
@@ -315,27 +320,19 @@ export function extractScreenshotPaths(progressContent: string, workDir: string)
   return paths;
 }
 
-/**
- * Get the relative path of a file within a git repo.
- */
-async function getRelativePath(workDir: string, absolutePath: string): Promise<string> {
-  // If path is already relative (starts within workDir), extract relative portion
-  if (absolutePath.startsWith(workDir)) {
-    return absolutePath.slice(workDir.length).replace(/^\//, "");
-  }
-  // Otherwise try git to resolve
-  try {
-    const result = await Bun.$`git -C ${workDir} ls-files --full-name ${absolutePath}`.text();
-    return result.trim();
-  } catch {
-    return basename(absolutePath);
-  }
+function getImageMimeType(filePath: string): string | null {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".png")) return "image/png";
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+  if (lower.endsWith(".gif")) return "image/gif";
+  if (lower.endsWith(".webp")) return "image/webp";
+  if (lower.endsWith(".svg")) return "image/svg+xml";
+  return null;
 }
 
 /**
  * Upload screenshots referenced in progress.txt to the PR as a comment.
- * Screenshots that are committed to the branch are referenced via raw GitHub URLs.
- * Screenshots not yet tracked are committed first, then referenced.
+ * This does not commit files; it only posts screenshots to the PR conversation.
  */
 export async function uploadProgressScreenshots(
   octokit: Octokit,
@@ -344,44 +341,56 @@ export async function uploadProgressScreenshots(
   prNumber: number,
   progressContent: string,
   workDir: string,
-  branch: string,
+  _branch: string,
 ): Promise<void> {
   const screenshotPaths = extractScreenshotPaths(progressContent, workDir);
   if (screenshotPaths.length === 0) return;
 
-  const imageEntries: Array<{ name: string; url: string }> = [];
+  const imageEntries: Array<{ name: string; dataUrl: string }> = [];
+  const skippedEntries: string[] = [];
+  const MAX_IMAGE_BYTES = 1_500_000;
 
   for (const filePath of screenshotPaths) {
     const file = Bun.file(filePath);
     if (!(await file.exists())) continue;
 
-    const relativePath = await getRelativePath(workDir, filePath);
     const name = basename(filePath);
+    const mimeType = getImageMimeType(filePath);
+    if (!mimeType) {
+      skippedEntries.push(`${name} (unsupported image type)`);
+      continue;
+    }
+
+    const size = file.size;
+    if (typeof size === "number" && size > MAX_IMAGE_BYTES) {
+      skippedEntries.push(`${name} (too large: ${(size / 1024 / 1024).toFixed(2)} MB)`);
+      continue;
+    }
 
-    // Check if file is tracked in git
     try {
-      await Bun.$`git -C ${workDir} ls-files --error-unmatch ${filePath}`.quiet();
+      const arrayBuffer = await file.arrayBuffer();
+      const base64 = Buffer.from(arrayBuffer).toString("base64");
+      const dataUrl = `data:${mimeType};base64,${base64}`;
+      imageEntries.push({ name, dataUrl });
     } catch {
-      // File not tracked - add and commit it
-      try {
-        await Bun.$`git -C ${workDir} add ${filePath}`.quiet();
-        await Bun.$`git -C ${workDir} commit -m ${"chore: add screenshot " + name}`.quiet();
-      } catch {
-        continue; // Skip if we can't commit
-      }
+      skippedEntries.push(`${name} (failed to read file)`);
+      continue;
     }
-
-    const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${relativePath}`;
-    imageEntries.push({ name, url: rawUrl });
   }
 
-  if (imageEntries.length === 0) return;
+  if (imageEntries.length === 0 && skippedEntries.length === 0) return;
 
   const body = [
     `🤖 **eternity-loop bot:** Screenshots from this run:\n`,
     ...imageEntries.map((entry, i) =>
-      `### Screenshot ${i + 1}\n![${entry.name}](${entry.url})\n`
+      `### Screenshot ${i + 1}\n![${entry.name}](${entry.dataUrl})\n`
     ),
+    ...(skippedEntries.length > 0
+      ? [
+        "### Skipped files",
+        ...skippedEntries.map((entry) => `- ${entry}`),
+      ]
+      : []),
   ].join("\n");
 
   await postPrComment(octokit, owner, repo, prNumber, body);

scripts/eternity-loop/workflows/review.ts

@@ -33,12 +33,16 @@ export class ReviewWorkflow implements Workflow {
     });
 
     const candidates = [...inReview, ...inProgress];
+    logDebug(`[review] Found ${candidates.length} candidate(s) in "In Review" or "In Progress" with prd label`);
     const octokit = createGitHubClient();
     const { owner, repo } = await getRepoInfo(ctx.workDir);
 
+    logDebug(`[review] Checking candidates for new PR comments since last commit in ${owner}/${repo}...`);
+
     let commentCount = 0;
     for (const issue of candidates) {
       const pr = await findPrByBranch(octokit, owner, repo, issue.branchName);
+      logDebug(`[review] Checking issue ${issue.identifier} (branch: ${issue.branchName}) - found PR: ${pr ? pr.number : "none"}`);
       if (!pr) continue;
 
       const latestCommitDate = await getLatestCommitDate(ctx.workDir, issue.branchName);