Merge origin/main and resolve conflicts

Co-authored-by: mrjf <180956+mrjf@users.noreply.github.com>

Author: Copilot

.github/workflows/autoloop.lock.yml

@@ -45,6 +45,7 @@ safe-outputs:
     title-prefix: "[Autoloop] "
     labels: [automation, autoloop]
     protected-files: fallback-to-issue
+    preserve-branch-name: true
     max: 1
   push-to-pull-request-branch:
     target: "*"
@@ -434,10 +435,26 @@ steps:
       # Look up existing PR for the selected program's canonical branch
       existing_pr = None
       head_branch = None
+
+      def verify_pr_is_open(pr_number):
+          """Check if a PR is still open via the GitHub API. Returns True if open."""
+          try:
+              verify_url = f"https://api.github.com/repos/{repo}/pulls/{pr_number}"
+              verify_req = urllib.request.Request(verify_url, headers={
+                  "Authorization": f"token {github_token}",
+                  "Accept": "application/vnd.github.v3+json",
+              })
+              with urllib.request.urlopen(verify_req, timeout=30) as verify_resp:
+                  pr_data = json.loads(verify_resp.read().decode())
+              return pr_data.get("state") == "open"
+          except Exception:
+              return True  # If we can't verify, assume it's open (best effort)
+
       if selected:
           head_branch = f"autoloop/{selected}"
           owner = repo.split("/")[0] if "/" in repo else ""
           if owner:
+              # Strategy 1: exact branch match (works when branch has no framework suffix)
               try:
                   pr_api_url = (
                       f"https://api.github.com/repos/{repo}/pulls"
@@ -451,22 +468,54 @@ steps:
                       open_prs = json.loads(pr_resp.read().decode())
                   if open_prs:
                       existing_pr = open_prs[0]["number"]
-                      print(f"  Found existing PR #{existing_pr} for branch {head_branch}")
-                  else:
-                      print(f"  No existing PR found for branch {head_branch}")
+                      print(f"  Found existing PR #{existing_pr} for exact branch {head_branch}")
               except Exception as e:
-                  print(f"  Warning: could not check for existing PRs: {e}")
+                  print(f"  Warning: could not check for existing PRs by exact branch: {e}")
+
+              # Strategy 2: search by title and branch prefix (catches framework-generated
+              # hash suffixes like autoloop/name-a1b2c3d4e5f6g7h8 created by create-pull-request)
+              if existing_pr is None:
+                  try:
+                      title_marker = f"[Autoloop: {selected}]"
+                      branch_prefix = head_branch  # e.g. autoloop/perf-comparison
+                      list_url = (
+                          f"https://api.github.com/repos/{repo}/pulls"
+                          f"?state=open&per_page=100&sort=created&direction=desc"
+                      )
+                      list_req = urllib.request.Request(list_url, headers={
+                          "Authorization": f"token {github_token}",
+                          "Accept": "application/vnd.github.v3+json",
+                      })
+                      with urllib.request.urlopen(list_req, timeout=30) as list_resp:
+                          all_open_prs = json.loads(list_resp.read().decode())
+                      # Match branch names: exact canonical name or canonical + framework hash suffix
+                      branch_pattern = re.compile(r'^' + re.escape(branch_prefix) + r'(-[0-9a-f]{16})?$')
+                      for pr in all_open_prs:
+                          pr_title = pr.get("title", "")
+                          pr_head_ref = pr.get("head", {}).get("ref", "")
+                          if title_marker in pr_title or branch_pattern.match(pr_head_ref):
+                              existing_pr = pr["number"]
+                              print(f"  Found existing PR #{existing_pr} by title/branch-prefix (branch: {pr_head_ref})")
+                              break
+                      if existing_pr is None:
+                          print(f"  No existing PR found for program {selected}")
+                  except Exception as e:
+                      print(f"  Warning: could not search for existing PRs by title/prefix: {e}")
           else:
               print(f"  Warning: could not parse owner from GITHUB_REPOSITORY='{repo}'")
 
-          # Also check the state file for a recorded PR number as fallback
+          # Strategy 3: check the state file for a recorded PR number as fallback
           if existing_pr is None:
               state = read_program_state(selected)
               pr_field = state.get("pr") or ""
               pr_match = re.match(r'^#?(\d+)$', pr_field.strip())
               if pr_match:
-                  existing_pr = int(pr_match.group(1))
-                  print(f"  Found PR #{existing_pr} from state file for {selected}")
+                  pr_num = int(pr_match.group(1))
+                  if verify_pr_is_open(pr_num):
+                      existing_pr = pr_num
+                      print(f"  Found open PR #{existing_pr} from state file for {selected}")
+                  else:
+                      print(f"  PR #{pr_num} from state file is no longer open — ignoring")
 
       result = {
           "selected": selected,

.github/workflows/autoloop.md

@@ -3,3 +3,5 @@ dist/
 *.tsbuildinfo
 package-lock.json
 *.tgz
+playground/benchmarks/
+playground/dist/

.gitignore

@@ -0,0 +1,21 @@
+"""Benchmark: Categorical from codes on 100k-element array"""
+import json, time
+import numpy as np
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 10
+
+categories = ["apple", "banana", "cherry", "date", "elderberry"]
+codes = np.arange(ROWS) % len(categories)
+
+for _ in range(WARMUP):
+    pd.Categorical.from_codes(codes, categories=categories)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.Categorical.from_codes(codes, categories=categories)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({ "function": "cat_from_codes", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total }))

benchmarks/pandas/bench_cat_from_codes.py

@@ -0,0 +1,21 @@
+"""Benchmark: cut (bin into 10 bins) on 100k-element Series"""
+import json, time
+import numpy as np
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 10
+
+data = (np.arange(ROWS) % 10000) * 0.01
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    pd.cut(s, 10)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.cut(s, 10)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({ "function": "cut", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total }))

benchmarks/pandas/bench_cut.py

@@ -0,0 +1,22 @@
+"""Benchmark: DataFrame covariance matrix on 1000x10 DataFrame"""
+import json, time
+import numpy as np
+import pandas as pd
+
+ROWS = 1_000
+COLS = 10
+WARMUP = 3
+ITERATIONS = 10
+
+data = {f"col{c}": np.sin(np.arange(ROWS) * 0.01 + c) for c in range(COLS)}
+df = pd.DataFrame(data)
+
+for _ in range(WARMUP):
+    df.cov()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    df.cov()
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({ "function": "dataframe_cov", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total }))

benchmarks/pandas/bench_dataframe_cov.py

@@ -0,0 +1,21 @@
+"""Benchmark: ewm std (alpha=0.1) on 100k-element Series"""
+import json, time
+import numpy as np
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 10
+
+data = np.sin(np.arange(ROWS) * 0.01)
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.ewm(alpha=0.1).std()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.ewm(alpha=0.1).std()
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({ "function": "ewm_std", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total }))

benchmarks/pandas/bench_ewm_std.py

@@ -0,0 +1,21 @@
+"""Benchmark: ewm var (alpha=0.1) on 100k-element Series"""
+import json, time
+import numpy as np
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 10
+
+data = np.sin(np.arange(ROWS) * 0.01)
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.ewm(alpha=0.1).var()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.ewm(alpha=0.1).var()
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({ "function": "ewm_var", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total }))

benchmarks/pandas/bench_ewm_var.py

@@ -0,0 +1,21 @@
+"""Benchmark: expanding std on 100k-element Series"""
+import json, time
+import numpy as np
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 10
+
+data = np.sin(np.arange(ROWS) * 0.01)
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.expanding().std()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.expanding().std()
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({ "function": "expanding_std", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total }))

benchmarks/pandas/bench_expanding_std.py

@@ -0,0 +1,21 @@
+"""Benchmark: expanding sum on 100k-element Series"""
+import json, time
+import numpy as np
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 10
+
+data = np.sin(np.arange(ROWS) * 0.01)
+s = pd.Series(data)
+
+for _ in range(WARMUP):
+    s.expanding().sum()
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.expanding().sum()
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({ "function": "expanding_sum", "mean_ms": total / ITERATIONS, "iterations": ITERATIONS, "total_ms": total }))