[WRONG BRANCH] promote dev onto main for v2.36.0

.github/scripts/closed-pr-branch-cleanup.cjs

@@ -16,11 +16,17 @@
 /** Branches that may never be deleted regardless of pull-request state. */
 const PROTECTED_BRANCHES = Object.freeze(["main", "dev", "preview", "gh-pages"]);
 
+/** Branch namespaces explicitly reserved for disposable pull-request work. */
+const DISPOSABLE_BRANCH_PREFIXES = Object.freeze(["codex/", "ingw/"]);
+
 /** Default grace period before a closed PR's head branch becomes eligible. */
 const DEFAULT_GRACE_DAYS = 14;
 
 function normalizeBranchName(value) {
-  return String(value || "").trim();
+  // Git permits non-ASCII whitespace in ref names, while String#trim removes
+  // it. Preserve API-provided branch identity byte-for-byte so two distinct
+  // refs cannot collapse into one deletion candidate.
+  return typeof value === "string" ? value : "";
 }
 
 /**
@@ -59,6 +65,7 @@ const KEEP_REASONS = Object.freeze({
   CROSS_REPOSITORY: "cross-repository-head",
   MISSING_CLOSED_AT: "missing-closed-at",
   WITHIN_GRACE: "within-grace-period",
+  OUTSIDE_DISPOSABLE_NAMESPACE: "outside-disposable-namespace",
   MOVED_SINCE_CLOSE: "branch-moved-since-close",
   UNKNOWN_HEAD_SHA: "unknown-head-sha",
 });
@@ -79,6 +86,11 @@ const KEEP_REASONS = Object.freeze({
  *   contributor's repository and this token has no business there.
  * - A grace period after `closed_at` leaves room to reopen a PR that was
  *   closed by mistake.
+ * - Only branches under namespaces explicitly reserved for disposable pull-
+ *   request work are eligible. Pull-request history alone must not authorize
+ *   deletion of an unrelated persistent branch.
+ * - Branch names are compared and emitted byte-for-byte. Normalizing Unicode
+ *   whitespace can merge distinct valid refs and delete the wrong branch.
  * - The branch must still POINT AT a commit one of those closed pull requests
  *   had as its head. Matching by NAME alone deletes reused work: `codex/`-style
  *   names get picked up again all the time, and a branch recreated for new work
@@ -178,6 +190,11 @@ function planClosedPrBranchDeletions({
       continue;
     }
 
+    if (!DISPOSABLE_BRANCH_PREFIXES.some((prefix) => branch.startsWith(prefix))) {
+      keeps.push({ branch, reason: KEEP_REASONS.OUTSIDE_DISPOSABLE_NAMESPACE });
+      continue;
+    }
+
     // The tip check, last because it is the most expensive claim to satisfy and
     // the cheaper rules above have already excluded most branches.
     //
@@ -219,6 +236,7 @@ function planClosedPrBranchDeletions({
 
 module.exports = {
   DEFAULT_GRACE_DAYS,
+  DISPOSABLE_BRANCH_PREFIXES,
   KEEP_REASONS,
   PROTECTED_BRANCHES,
   isProtectedBranch,

.github/scripts/closed-pr-branch-cleanup.test.cjs

@@ -4,13 +4,17 @@ const { describe, it } = require("node:test");
 const assert = require("node:assert/strict");
 const {
   DEFAULT_GRACE_DAYS,
+  DISPOSABLE_BRANCH_PREFIXES,
   KEEP_REASONS,
   isProtectedBranch,
   planClosedPrBranchDeletions,
 } = require("./closed-pr-branch-cleanup.cjs");
 
 const NOW = Date.parse("2026-08-26T00:00:00Z");
 const DAY = 24 * 60 * 60 * 1000;
+const HEAD_OID = "a".repeat(40);
+const OTHER_OID = "b".repeat(40);
+const NBSP = "\u00a0";
 const longAgo = new Date(NOW - 60 * DAY).toISOString();
 
 function closedPr(overrides) {
@@ -20,6 +24,7 @@ function closedPr(overrides) {
     merged: false,
     isCrossRepository: false,
     headRefName: "codex/example",
+    headRefOid: HEAD_OID,
     baseRefName: "dev",
     closedAt: longAgo,
     ...overrides,
@@ -42,13 +47,17 @@ describe("isProtectedBranch", () => {
     }
     assert.equal(isProtectedBranch("codex/dev"), false);
   });
+
+  it("declares the disposable pull-request branch namespaces", () => {
+    assert.deepEqual(DISPOSABLE_BRANCH_PREFIXES, ["codex/", "ingw/"]);
+  });
 });
 
 describe("planClosedPrBranchDeletions", () => {
   it("deletes a branch whose only pull request closed unmerged past the grace period", () => {
     const result = planClosedPrBranchDeletions({
       pullRequests: [closedPr({ number: 42, headRefName: "codex/stale" })],
-      branches: ["codex/stale", "dev"],
+      branches: [{ name: "codex/stale", oid: HEAD_OID }, "dev"],
       now: NOW,
     });
     assert.deepEqual(deletedBranches(result), ["codex/stale"]);
@@ -147,13 +156,58 @@ describe("planClosedPrBranchDeletions", () => {
   it("ignores branches that no pull request ever used", () => {
     const result = planClosedPrBranchDeletions({
       pullRequests: [closedPr({ number: 80, headRefName: "codex/known" })],
-      branches: ["codex/known", "codex/never-a-pr"],
+      branches: [
+        { name: "codex/known", oid: HEAD_OID },
+        { name: "codex/never-a-pr", oid: HEAD_OID },
+      ],
       now: NOW,
     });
     assert.deepEqual(deletedBranches(result), ["codex/known"]);
     assert.equal(keepReason(result, "codex/never-a-pr"), null);
   });
 
+  it("keeps a persistent branch even when a closed pull request still matches its tip", () => {
+    const branch = "release/maintenance";
+    const result = planClosedPrBranchDeletions({
+      pullRequests: [closedPr({ number: 85, headRefName: branch })],
+      branches: [{ name: branch, oid: HEAD_OID }],
+      now: NOW,
+    });
+    assert.deepEqual(deletedBranches(result), []);
+    assert.equal(
+      keepReason(result, branch),
+      KEEP_REASONS.OUTSIDE_DISPOSABLE_NAMESPACE,
+    );
+  });
+
+  it("preserves Unicode whitespace so distinct valid refs never collapse", () => {
+    const disposable = `codex/live${NBSP}`;
+    const result = planClosedPrBranchDeletions({
+      pullRequests: [closedPr({ number: 86, headRefName: disposable })],
+      branches: [
+        { name: "codex/live", oid: OTHER_OID },
+        { name: disposable, oid: HEAD_OID },
+      ],
+      now: NOW,
+    });
+    assert.deepEqual(result.deletions, [{ branch: disposable, pullRequests: [86] }]);
+    assert.equal(keepReason(result, "codex/live"), null);
+  });
+
+  it("does not trim leading Unicode whitespace into a disposable namespace", () => {
+    const branch = `${NBSP}codex/persistent`;
+    const result = planClosedPrBranchDeletions({
+      pullRequests: [closedPr({ number: 87, headRefName: branch })],
+      branches: [{ name: branch, oid: HEAD_OID }],
+      now: NOW,
+    });
+    assert.deepEqual(deletedBranches(result), []);
+    assert.equal(
+      keepReason(result, branch),
+      KEEP_REASONS.OUTSIDE_DISPOSABLE_NAMESPACE,
+    );
+  });
+
   it("only plans deletions for branches that still exist", () => {
     const result = planClosedPrBranchDeletions({
       pullRequests: [closedPr({ number: 90, headRefName: "codex/already-gone" })],

AGENTS.md

@@ -171,7 +171,8 @@ it binds you regardless of which mechanism is within reach.
 ```bash
 bun install
 bun run typecheck      # bun x tsc --noEmit (strict)
-bun run test           # full tests/ suite
+bun run test:changed   # import-graph tests against the resolved `dev` merge base
+bun run test           # full tests/ suite (PR-ready / explicit ask only)
 bun run lint:gui       # GUI eslint
 bun run privacy:scan   # credential/privacy scan used by CI
 bun run build:gui      # Vite GUI build
@@ -191,17 +192,55 @@ also if the hand-written pages name a command the registry does not have. That s
 hypothetical: it caught a documented `ocx request-history` that never existed.
 
 During implementation, use the smallest focused checks that directly cover the
-changed subsystem. Do not run repository-wide `bun run typecheck` or
-`bun run test` for a scoped change unless the change affects shared runtime,
-routing, config, server behavior, a focused result is failed or ambiguous, or
-the user explicitly asks for full validation.
+changed subsystem. Prefer `bun test tests/<name>.test.ts` for a known file, or
+`bun run test:changed` when the touch set is broader than one file. Do **not**
+run repository-wide `bun run test` or a bare `bun test` with no file arguments
+for a scoped change by default. `bun run test:changed` follows Bun's parsed module graph: it
+selects test files that import changed modules, but it cannot see dependencies
+expressed through subprocesses, source files read as data, or golden/derived
+files. Run the relevant focused tests explicitly for those paths; if no reliable
+focused set covers them, the full suite is required even for a scoped change.
+That indirect-dependency case is the explicit exception to the scoped-change
+default. The full suite is ~850 files, so otherwise reserve it for a failed or
+ambiguous focused result, an explicit user request, or the PR-ready gate below.
 
 Before creating or updating a non-trivial PR as review-ready, or before
 approving such a PR, run `bun run typecheck` and `bun run test`. CI runs these
 on Linux, Windows, and macOS.
 
 Do not rerun passing checks on unchanged code merely for additional confidence.
 
+## Minimal containers and agent sandboxes
+
+Fresh dev containers and agent sandboxes (Cursor Cloud, devcontainers, CI
+images) often ship Node but not Bun. Install it first:
+
+```bash
+curl -fsSL https://bun.sh/install | bash   # installs ~/.bun/bin/bun
+export PATH="$HOME/.bun/bin:$PATH"
+bun install && (cd gui && bun install)
+```
+
+Run the proxy with `bun run src/cli/index.ts start --port <port>`. `/healthz`
+reports status, `/` serves the dashboard, and the management API requires the
+admin token the server writes to `$OPENCODEX_HOME/admin-api-token` at startup.
+
+`bun run test` has five known environment-only failures in such containers.
+They are not regressions; do not re-investigate them:
+
+- `service diagnostics > status summary exposes the service log path`,
+  `CLI subcommand help > status prints diagnostics without starting the proxy`,
+  and `CLI subcommand help > invalid service and codex-shim usage include
+  remove alias` require a running systemd init; in a container PID 1 is
+  typically `tini` or another minimal init, so service commands report
+  "systemd not found".
+- `package tree integrity > an in-place rewrite of the same byte length is
+  still a replacement` and `Codex Log Guard inspection > repeat inspection is
+  memoized and invalidated by a write` rely on filesystem mtime granularity
+  that some container filesystems do not provide.
+
+Everything else passes (15480 pass / 16 skip / 5 fail as of 2.35.0).
+
 ## Issues and pull requests (agents)
 
 Agent-created issues and PRs must use the repository templates. The gates
@@ -295,8 +334,9 @@ reviewers (Codex, CodeRabbit).
   assumptions about a compile step, or code paths that break `bun run
   typecheck` / `bun run test`.
 - **Tests:** behavior changes in `src/` need a focused regression test near
-  the existing tests for that subsystem. Shared routing, adapter, config, or
-  server changes need the full suite green.
+  the existing tests for that subsystem. During implementation, run the relevant
+  focused files and use `bun run test:changed` for import-connected coverage as
+  described above; the full suite is the PR-ready gate.
 - **Docs sync:** user-facing behavior changes should update `docs-site/` (and
   keep translated locales from contradicting the English source).
 - **Privacy:** `bun run privacy:scan` must stay green; never introduce logging

devlog/_fin/260828_kiro_turn_termination/021_audit_round3.md

@@ -0,0 +1,71 @@
+# wp2 audit round 3 — the outer drain must not learn about completions
+
+Reviewer: independent explorer lane, read-only, HEAD `a43e4cda`.
+Verdict: **FAIL** on the plan as written in `020_wp2_duplicate_answer.md`.
+This document records the finding and the corrected design.
+
+## What the reviewer accepted
+
+- Consuming the retained collection on a valid completion IS sufficient to remove
+  the user-visible duplicate. Required-mode text is held only in `deferred`
+  (`src/adapters/kiro.ts:1174-1179`, `:1207`), fallback text only in
+  `fallbackEvents` (`:1202-1205`), and a valid completion never live-flushes that
+  run because a completion alongside a real tool call is already a protocol error
+  (`:1260-1261`). With the commentary `text_delta` gone, `src/bridge.ts` never
+  splits the message.
+- There is **no third emitter**. `:1523` builds a new event from
+  `completionAnswer`; it does not read `deferred`. The early-loop yields at
+  `:1398` and `:1418` only flush `deferred` when a real tool starts (`:1175`).
+- Dropping `text_delta` while keeping non-text retained events loses nothing
+  load-bearing on this path. Tool events never sit in the collection — they splice
+  live and forbid a valid completion.
+- `releaseEvent` is idempotent via its `eventBytes` map guard (`:808-810`), so a
+  double release cannot double-credit the budget.
+
+## The blocker
+
+`020`'s option 1 says to consume the collection at BOTH readers — the inner flush
+and the outer drain in `parseKiroAttempt` (`:996-1001`). The reviewer showed the
+second half is wrong:
+
+> `996-1001` is also the leftover flush for early `terminal` returns that never
+> hit `1468` (`1405-1413`). Dropping `text_delta` there without a completion flag
+> hides the only commentary.
+
+That outer drain is the release path for stream, protocol, and provider failures —
+the row `020`'s own table requires to stay intact. A turn that fails after emitting
+progress prose would lose that prose entirely, which is a worse defect than the
+duplicate: the user would see an error with no indication of what the model had
+been doing.
+
+## Corrected design
+
+The inner site is the only consumer, and it leaves the collection **empty**:
+
+1. `src/adapters/kiro.ts:1468`, `mode === "required"`: when
+   `completionAnswer !== undefined`, splice the collection and consume it — drop
+   each `text_delta` after releasing its retention, yield every non-text event and
+   release it. When there is no completion answer, flush exactly as today.
+2. `:1474`, `mode === "text_fallback"`: this branch is **already** gated on
+   `completionAnswer !== undefined`, so the same consume applies there and nowhere
+   else in that mode.
+3. `:996-1001`, the outer drain: **unchanged**. Because step 1 splices, there is
+   nothing left for it to emit on the completion path, and it keeps its full
+   flush behaviour for every early-terminal path.
+
+The correction is that suppression is expressed by emptying the collection at the
+one site that knows a completion arrived — not by teaching a second,
+failure-serving reader to discard text.
+
+Untouched, per `020`'s release table: the `sawRealTool` flush (`:1483`), the
+plain-text promotion (`:1490-1498`), and the empty/reasoning-only fallback
+(`:1505`).
+
+## Budget note
+
+The reviewer's condition for a leak is "splice, skip `releaseEvent`, and skip
+`releaseAll`". The consume path releases every event it drops, and
+`releaseRetained`/`releaseAll` still runs for the `trackReplacement` remainder
+(`:801-803`), which is not tracked in `eventBytes`. A test asserts the budget
+returns to baseline.
+