[WRONG BRANCH] Fork を上流 v2.88.0 へ更新（refusal-terminal は上流取り込みにより撤去）

.dockerignore

@@ -0,0 +1,36 @@
+**
+
+!package.json
+!bun.lock
+!tsconfig.json
+
+# The manifest stage needs Git's tracked-file INVENTORY and nothing else: `git ls-files` reads
+# the index and never opens an object or a ref. Admitting those two files costs about 1 MB;
+# admitting .git wholesale would put 1.3 GB in every local build context. The stage supplies the
+# empty objects/ and refs/ directories Git's repository check insists on, in a scratch GIT_DIR.
+# No COPY includes either file, so neither reaches an image layer.
+!.git/
+.git/**
+!.git/index
+!.git/HEAD
+
+!src/
+!src/**
+# Optional compatibility path for hosts that already generated the canonical artifact.
+!src/generated/compatibility-version.json
+
+!scripts/
+scripts/**
+!scripts/model-metadata.source.json
+!scripts/generate-compatibility-version.ts
+
+!docker/
+!docker/**
+
+!gui/
+!gui/**
+gui/node_modules/
+gui/dist/
+gui/.vite/
+
+**/*.log

.github/AGENTS.md

@@ -22,5 +22,5 @@ change requires explicit security review under `MAINTAINERS.md`.
 
 - Inspect the complete workflow diff, including event triggers, permissions, conditions, interpolation, and shell behavior.
 - Run the local commands represented by changed workflow steps where possible.
-- Run `bun run prepush` for CI, release, dependency, packaging, or cross-platform workflow changes.
+- Follow the root validation policy: run the suite by default; if a full run is too costly, run at least focused regression tests and document the reason and remaining coverage. Required CI checks still apply before merge.
 - Do not claim the workflow itself passed until GitHub Actions reports success for the exact commit.

.github/CODEOWNERS

@@ -1,11 +1,11 @@
 # Default reviewers
-* @lidge-jun @Ingwannu @Wibias
+* @lidge-jun @Ingwannu
 
 # High-impact runtime behavior
-/src/adapters/ @lidge-jun @Ingwannu @Wibias
-/src/providers/ @lidge-jun @Ingwannu @Wibias
-/src/codex/ @lidge-jun @Ingwannu @Wibias
-/src/server/ @lidge-jun @Ingwannu @Wibias
+/src/adapters/ @lidge-jun @Ingwannu
+/src/providers/ @lidge-jun @Ingwannu
+/src/codex/ @lidge-jun @Ingwannu
+/src/server/ @lidge-jun @Ingwannu
 
 # Repository automation and release security
 /.github/ @lidge-jun @Ingwannu
@@ -14,6 +14,7 @@
 /bunfig.toml @lidge-jun @Ingwannu
 /scripts/release.ts @lidge-jun @Ingwannu
 /scripts/release-notes.ts @lidge-jun @Ingwannu
+/scripts/release-version-sources.ts @lidge-jun @Ingwannu
 /scripts/prepare-package.ts @lidge-jun @Ingwannu
 /package.json @lidge-jun @Ingwannu
 /bun.lock @lidge-jun @Ingwannu
@@ -32,3 +33,15 @@
 **/AGENTS.md @lidge-jun @Ingwannu
 /MAINTAINERS.md @lidge-jun @Ingwannu
 /SECURITY.md @lidge-jun @Ingwannu
+
+# Proxy core boundary — owner approval required.
+# These four files carry every user's request path, including users of no optional
+# subsystem. Optional subsystems (Compatibility Lab and anything added later) register
+# into core-owned slots at activation instead of being imported here; the invariant is
+# enforced by tests/lab/core-lab-boundary.test.ts and designed in
+# devlog/_fin/260814_lab_core_decoupling/.
+# Last-match-wins: this block must stay below /src/server/ to take effect.
+/src/router.ts @lidge-jun
+/src/server/index.ts @lidge-jun
+/src/server/lifecycle.ts @lidge-jun
+/src/server/responses/core.ts @lidge-jun

.github/ISSUE_TEMPLATE/documentation.yml

@@ -28,7 +28,7 @@ body:
     attributes:
       label: Documentation location
       description: Public documentation URL or repository path.
-      placeholder: "https://opencodex.me/providers/ or docs/providers.md"
+      placeholder: "https://opencodex.me/guides/providers/ or docs-site/src/content/docs/guides/providers.md"
     validations:
       required: true
 

.github/actions/setup-project-bun/action.yml

@@ -0,0 +1,56 @@
+name: Setup project Bun
+description: >-
+  Install the package.json Bun pin for a job's role: dependencies.bun for
+  runtime (default), or testRunnerBun for test-runner.
+
+# Runtime 1.4.2 fixes #6684's Windows Bun.fetch stream truncation. The test runner
+# skipped 1.4.2: #4821 reverted #4064 after its multi-file --isolate preload segfault
+# (#6713 run 37631558263: Linux 1/4, macOS 2/2, Windows 9/9). It moved from 1.4.0 to
+# 1.4.3 for oven-sh/bun#44581: 1.4.0's Bun.spawnSync could lose a child's exit after
+# finalizers ran inside an earlier call and spin past its own timeout (#4956).
+# Rejoin only after the upstream runner crash is fixed and a green lane=all
+# dispatch proves the unified version; then delete testRunnerBun and this role input.
+inputs:
+  role:
+    description: Bun role to install (runtime or test-runner).
+    required: false
+    default: runtime
+
+outputs:
+  version:
+    description: The resolved Bun version string.
+    value: ${{ steps.resolve.outputs.version }}
+
+runs:
+  using: composite
+  steps:
+    - name: Resolve project Bun version
+      id: resolve
+      shell: bash
+      env:
+        BUN_ROLE: ${{ inputs.role }}
+      run: |
+        node <<'NODE'
+        const pkg = require('./package.json');
+        const role = process.env.BUN_ROLE;
+        let key;
+        let version;
+        switch (role) {
+          case 'runtime': key = 'dependencies.bun'; version = pkg.dependencies?.bun; break;
+          case 'test-runner': key = 'testRunnerBun'; version = pkg.testRunnerBun; break;
+          default:
+            console.error(`::error::Unknown Bun role: ${role}`);
+            process.exit(1);
+        }
+        if (typeof version !== 'string' || version !== version.trim() || !/^\d+\.\d+\.\d+$/.test(version)) {
+          console.error(`::error::Missing or invalid package.json ${key} for Bun role ${role}`);
+          process.exit(1);
+        }
+        require('node:fs').appendFileSync(process.env.GITHUB_OUTPUT, `version=${version}\n`);
+        console.log(`Using Bun ${version} from package.json ${key} (${role})`);
+        NODE
+
+    - name: Setup Bun
+      uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2
+      with:
+        bun-version: ${{ steps.resolve.outputs.version }}

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

@@ -0,0 +1,244 @@
+"use strict";
+
+/**
+ * Deletion planning for branches left behind by closed-without-merge pull
+ * requests.
+ *
+ * GitHub's repository-level `delete_branch_on_merge` only fires on merge, so a
+ * PR that is closed unmerged leaves its head branch in the repository forever.
+ * This module decides which of those branches may be deleted; the workflow
+ * performs the deletion.
+ *
+ * Kept as a pure module so the safety rules can be unit-tested without Actions
+ * and without a live repository.
+ */
+
+/** 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) {
+  // 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 : "";
+}
+
+/**
+ * A commit id, lowercased for comparison.
+ *
+ * The REST and GraphQL APIs are not consistent about case, and a full 40-character
+ * sha compared case-sensitively against an abbreviated or upper-case one silently
+ * reads as "different" - which here would mean "keep", so the failure direction is
+ * safe, but it would make the guard useless rather than protective. Anything that
+ * is not a plausible hex object id becomes null, i.e. unknown.
+ */
+function normalizeOid(value) {
+  const text = String(value || "").trim().toLowerCase();
+  return /^[0-9a-f]{7,64}$/.test(text) ? text : null;
+}
+
+function isProtectedBranch(name) {
+  return PROTECTED_BRANCHES.includes(normalizeBranchName(name));
+}
+
+function toTimestamp(value) {
+  if (!value) return null;
+  const ms = Date.parse(String(value));
+  return Number.isFinite(ms) ? ms : null;
+}
+
+/**
+ * Reasons a candidate branch is kept. Exported so the workflow can log a
+ * stable, greppable verdict per branch instead of a free-form sentence.
+ */
+const KEEP_REASONS = Object.freeze({
+  PROTECTED: "protected-branch",
+  MERGED: "pull-request-merged",
+  OPEN: "open-pull-request",
+  BASE_OF_OPEN: "base-of-open-pull-request",
+  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",
+});
+
+/**
+ * Plan deletions for head branches of closed-unmerged pull requests.
+ *
+ * Every rule here is a safety rule, and each one exists because the opposite
+ * behavior destroys work that is still referenced:
+ *
+ * - A branch is a candidate only when *every* pull request that ever used it as
+ *   a head is closed and unmerged. One open or merged PR on the same branch
+ *   keeps it, because reopening a PR whose head branch is gone cannot restore
+ *   the commits.
+ * - A branch that is the base of an open pull request is kept. Deleting it
+ *   closes the stacked child PR that targets it.
+ * - Cross-repository (fork) heads are never touched: they live in the
+ *   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
+ *   inherits the closed history of every PR that ever used that name. The tip
+ *   moved, so the branch is not the closed PR's branch any more - it only shares
+ *   its label.
+ * - A branch whose current tip cannot be determined is kept. An unknown tip is
+ *   not evidence of an abandoned branch, and this job's mistakes are not
+ *   recoverable.
+ *
+ * @param {object} input
+ * @param {Array<object>} input.pullRequests Pull requests with
+ *   `headRefName`, `headRefOid`, `baseRefName`, `state`, `merged`, `closedAt`,
+ *   and `isCrossRepository`.
+ * @param {Array<string|{name: string, oid?: string}>} input.branches Branches
+ *   that currently exist. A bare string carries no tip, which is treated as an
+ *   unknown tip and kept.
+ * @param {number} [input.now] Current time in milliseconds.
+ * @param {number} [input.graceDays] Days to wait after `closedAt`.
+ * @returns {{ deletions: Array<{branch: string, pullRequests: number[]}>,
+ *   keeps: Array<{branch: string, reason: string}> }}
+ */
+function planClosedPrBranchDeletions({
+  pullRequests = [],
+  branches = [],
+  now = Date.now(),
+  graceDays = DEFAULT_GRACE_DAYS,
+}) {
+  // Accepts both shapes so an older caller passing bare names still works - it
+  // just gets the conservative answer, because a name without a tip cannot be
+  // proven safe to delete.
+  /** @type {Map<string, string|null>} */
+  const existing = new Map();
+  for (const entry of branches) {
+    const name = normalizeBranchName(typeof entry === "string" ? entry : entry && entry.name);
+    if (!name) continue;
+    const oid = typeof entry === "string" ? null : normalizeOid(entry && entry.oid);
+    existing.set(name, oid);
+  }
+  const graceMs = Math.max(0, Number(graceDays) || 0) * 24 * 60 * 60 * 1000;
+
+  /** @type {Map<string, object[]>} */
+  const byHead = new Map();
+  const openBases = new Set();
+
+  for (const pr of pullRequests) {
+    const head = normalizeBranchName(pr && pr.headRefName);
+    if (head) {
+      const list = byHead.get(head) || [];
+      list.push(pr);
+      byHead.set(head, list);
+    }
+    const isOpen = String(pr && pr.state).toUpperCase() === "OPEN";
+    if (isOpen) {
+      const base = normalizeBranchName(pr && pr.baseRefName);
+      if (base) openBases.add(base);
+    }
+  }
+
+  const deletions = [];
+  const keeps = [];
+
+  for (const branch of [...existing.keys()].sort()) {
+    if (isProtectedBranch(branch)) {
+      keeps.push({ branch, reason: KEEP_REASONS.PROTECTED });
+      continue;
+    }
+
+    const related = byHead.get(branch) || [];
+    if (related.length === 0) continue; // No PR ever used it; out of scope.
+
+    if (related.some((pr) => pr && pr.isCrossRepository === true)) {
+      keeps.push({ branch, reason: KEEP_REASONS.CROSS_REPOSITORY });
+      continue;
+    }
+    if (related.some((pr) => pr && pr.merged === true)) {
+      keeps.push({ branch, reason: KEEP_REASONS.MERGED });
+      continue;
+    }
+    if (related.some((pr) => String(pr && pr.state).toUpperCase() === "OPEN")) {
+      keeps.push({ branch, reason: KEEP_REASONS.OPEN });
+      continue;
+    }
+    if (openBases.has(branch)) {
+      keeps.push({ branch, reason: KEEP_REASONS.BASE_OF_OPEN });
+      continue;
+    }
+
+    const closedTimestamps = related.map((pr) => toTimestamp(pr && pr.closedAt));
+    if (closedTimestamps.some((ts) => ts === null)) {
+      keeps.push({ branch, reason: KEEP_REASONS.MISSING_CLOSED_AT });
+      continue;
+    }
+    const newestClosedAt = Math.max(...closedTimestamps);
+    if (now - newestClosedAt < graceMs) {
+      keeps.push({ branch, reason: KEEP_REASONS.WITHIN_GRACE });
+      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.
+    //
+    // A closed PR's head branch is only THIS branch if the branch still points at
+    // a commit that PR had as its head. Without this, a name reused for new work
+    // is deleted on the strength of an unrelated PR that happened to share the
+    // label months earlier - and a deleted branch whose commits were never pushed
+    // anywhere else is gone.
+    const currentOid = existing.get(branch) || null;
+    if (!currentOid) {
+      keeps.push({ branch, reason: KEEP_REASONS.UNKNOWN_HEAD_SHA });
+      continue;
+    }
+    const closedOids = new Set(
+      related.map((pr) => normalizeOid(pr && pr.headRefOid)).filter(Boolean),
+    );
+    // An empty set means the API gave us no head SHA for any of them, which is the
+    // unknown case again rather than a licence to delete.
+    if (closedOids.size === 0) {
+      keeps.push({ branch, reason: KEEP_REASONS.UNKNOWN_HEAD_SHA });
+      continue;
+    }
+    if (!closedOids.has(currentOid)) {
+      keeps.push({ branch, reason: KEEP_REASONS.MOVED_SINCE_CLOSE });
+      continue;
+    }
+
+    deletions.push({
+      branch,
+      pullRequests: related
+        .map((pr) => Number(pr && pr.number))
+        .filter((n) => Number.isFinite(n))
+        .sort((a, b) => a - b),
+    });
+  }
+
+  return { deletions, keeps };
+}
+
+module.exports = {
+  DEFAULT_GRACE_DAYS,
+  DISPOSABLE_BRANCH_PREFIXES,
+  KEEP_REASONS,
+  PROTECTED_BRANCHES,
+  isProtectedBranch,
+  planClosedPrBranchDeletions,
+};