Merge branch 'main' into octo/20260801-text-to-image-tool-recvqqFfIZ8U41

Author: wenshao

.github/CODEOWNERS

@@ -3,10 +3,10 @@
 # ============================================================
 
 # --- CODEOWNERS file itself ---
-/.github/CODEOWNERS    @pomelo-nwu
+/.github/CODEOWNERS    @pomelo-nwu @wenshao
 
 # --- Core package ---
-/packages/core/        @wenshao @tanzhenxin @yiliang114 @LaZzyMan
+/packages/core/        @wenshao @tanzhenxin @yiliang114 @LaZzyMan @doudouOUC
 
 # --- CUA Driver & Mobile MCP ---
 /packages/cua-driver/  @LaZzyMan

.github/actions/configure-windows-runner/action.yml

@@ -0,0 +1,21 @@
+name: 'Configure Windows self-hosted runner'
+description: 'Tunes a self-hosted Windows runner for the test gates: exports the Linux gates'' C.UTF-8 locale env (inert on Windows, where Node collates through ICU), redirects TEMP/TMP to RUNNER_TEMP, and puts Git Bash on PATH for bash-shell steps. Runs after actions/checkout because repository-local actions resolve from the workspace; callers turn off autocrlf before the checkout itself. Shared by the Windows merge-queue gate and the runner smoke workflow so both always run an identical configuration.'
+
+runs:
+  using: 'composite'
+  steps:
+    - name: 'Configure Windows test environment'
+      # Self-hosted runners have Windows PowerShell, not necessarily pwsh.
+      # Force UTF-8 so GITHUB_ENV/GITHUB_PATH are not written as UTF-16LE.
+      shell: 'powershell'
+      run: |-
+        $ErrorActionPreference = 'Stop'
+        "TEMP=$env:RUNNER_TEMP" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+        "TMP=$env:RUNNER_TEMP" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+        "LC_ALL=C.UTF-8" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+        $gitBash = 'C:\Program Files\Git\bin'
+        if (!(Test-Path $gitBash)) {
+          Write-Output "::error::Git Bash not found at $gitBash"
+          exit 1
+        }
+        $gitBash | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append

.github/actions/self-hosted-node/action.yml

@@ -0,0 +1,17 @@
+name: 'Self-hosted Node.js preflight'
+description: 'Preflight for self-hosted runners that reuse their pre-installed Node.js instead of downloading one on ECS, where nodejs.org may be unreachable through the egress proxy: fails the job when Node is missing and warns when the major version is not 22.'
+
+runs:
+  using: 'composite'
+  steps:
+    - name: 'Use pre-installed Node.js'
+      shell: 'bash'
+      run: |-
+        if ! command -v node >/dev/null 2>&1; then
+          echo "::error::Node.js is not on PATH for this self-hosted runner. Provision Node 22.x or set the MAINTAINER_ECS_RUNNER_DISABLED repository variable to 'true' to route this gate back to hosted runners."
+          exit 1
+        fi
+        echo "Using pre-installed Node $(node -v) / npm $(npm -v)"
+        if [[ "$(node -p 'process.versions.node.split(".")[0]')" != "22" ]]; then
+          echo "::warning::Expected Node 22.x but found $(node -v); tests will run against the runner's Node."
+        fi

.github/actions/verify-checkout-head/action.yml

@@ -0,0 +1,21 @@
+name: 'Verify Checkout Head'
+description: 'Fails the job when the checked-out tree does not contain the expected head commit, so a stale checkout (e.g. a caching egress proxy serving an old ref) is never silently tested into a merge. Cheap: one merge-base, sub-second.'
+
+inputs:
+  expected_sha:
+    description: 'Commit SHA that must be an ancestor of the checked-out HEAD.'
+    required: true
+
+runs:
+  using: 'composite'
+  steps:
+    - name: 'Verify checkout includes expected head commit'
+      shell: 'bash'
+      env:
+        EXPECTED_SHA: '${{ inputs.expected_sha }}'
+      run: |-
+        if ! git merge-base --is-ancestor "${EXPECTED_SHA}" HEAD; then
+          echo "::error::Checked out ref does not contain expected head ${EXPECTED_SHA}."
+          git log --oneline --decorate -5
+          exit 1
+        fi

.github/assets/exit-resume-echo/01-baseline-v0.21.4-blank-after-exit.png

@@ -0,0 +1,32 @@
+{
+  "$comment": "Label-driven issue assignment map; areas are keyed on the existing issue label taxonomy. Assignment is a pure function of an issue's labels — no model output is involved. Owners need push access but do NOT need a CODEOWNERS entry; every candidate is re-checked against the collaborator API at write time, so adding a login here cannot grant access to someone who lacks it. Areas match in file order, first match wins. See docs/design/2026-08-07-issue-auto-assignment.md.",
+  "requireLabels": ["need-discussion"],
+  "skipLabels": [
+    "welcome-pr",
+    "feature/need-help",
+    "good first issue",
+    "help wanted",
+    "autofix/approved",
+    "autofix/in-progress"
+  ],
+  "areas": [
+    {
+      "name": "core",
+      "labels": ["category/core", "scope/core"],
+      "owners": [
+        "wenshao",
+        "tanzhenxin",
+        "yiliang114",
+        "LaZzyMan",
+        "doudouOUC",
+        "pomelo-nwu",
+        "DennisYu07",
+        "jifeng",
+        "chiga0",
+        "qqqys",
+        "ytahdn",
+        "BenGuanRan"
+      ]
+    }
+  ]
+}

.github/assets/exit-resume-echo/02-pr-exit-echo.png

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+// Assign an issue to an area owner, derived purely from the issue's labels.
+//
+// This script never reads issue title, body, or comments, so untrusted issue
+// text cannot steer the assignment. The triage agent's only influence is the
+// labels it applies, drawn from the repository's existing label taxonomy; the
+// label -> owner map lives in .github/issue-owners.json and is reviewed like
+// any other checked-in file. Push access is re-verified against the live
+// collaborator API before every write, so an edit to that map cannot assign
+// someone who does not already have permission.
+import { appendFileSync, readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
+
+const OWNERS_FILE = '.github/issue-owners.json';
+const WRITE_PERMISSIONS = new Set(['admin', 'maintain', 'write']);
+const LOGIN = /^(?!.*--)[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/;
+
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === 'string');
+}
+
+export function loadPolicy(raw) {
+  const policy = JSON.parse(raw);
+  if (!policy || typeof policy !== 'object' || Array.isArray(policy)) {
+    throw new Error(`${OWNERS_FILE}: not an object`);
+  }
+  // An empty label entry can never match; in requireLabels it would silently
+  // skip every issue on a green run, so reject it like other malformed config.
+  if (
+    !isStringArray(policy.requireLabels) ||
+    !isStringArray(policy.skipLabels) ||
+    policy.requireLabels.some((label) => label.length === 0) ||
+    policy.skipLabels.some((label) => label.length === 0)
+  ) {
+    throw new Error(
+      `${OWNERS_FILE}: requireLabels/skipLabels must be non-empty strings`,
+    );
+  }
+  if (!Array.isArray(policy.areas) || policy.areas.length === 0) {
+    throw new Error(`${OWNERS_FILE}: areas must be a non-empty array`);
+  }
+  const areaNames = new Set();
+  for (const area of policy.areas) {
+    if (typeof area?.name !== 'string' || area.name.length === 0) {
+      throw new Error(`${OWNERS_FILE}: every area needs a name`);
+    }
+    // First match wins, so two areas sharing a name silently shadow one another.
+    if (areaNames.has(area.name)) {
+      throw new Error(`${OWNERS_FILE}: duplicate area ${area.name}`);
+    }
+    areaNames.add(area.name);
+    if (
+      !isStringArray(area.labels) ||
+      area.labels.length === 0 ||
+      area.labels.some((label) => label.length === 0)
+    ) {
+      throw new Error(`${OWNERS_FILE}: area ${area.name} needs labels`);
+    }
+    if (!Array.isArray(area.owners) || area.owners.length === 0) {
+      throw new Error(`${OWNERS_FILE}: area ${area.name} needs owners`);
+    }
+    const seen = new Set();
+    for (const owner of area.owners) {
+      // Rejected here rather than at the gh call so a typo fails the config,
+      // not a single assignment attempt.
+      if (typeof owner !== 'string' || !LOGIN.test(owner)) {
+        throw new Error(`${OWNERS_FILE}: invalid login in ${area.name}`);
+      }
+      // A repeated login would be counted twice and win ties unfairly.
+      const normalizedOwner = owner.toLowerCase();
+      if (seen.has(normalizedOwner)) {
+        throw new Error(`${OWNERS_FILE}: duplicate owner ${owner}`);
+      }
+      seen.add(normalizedOwner);
+    }
+  }
+  return policy;
+}
+
+// Returns a human-readable reason to skip, or null to proceed. Ordered so the
+// most informative reason wins when several apply.
+export function skipReason(policy, issue) {
+  const labels = new Set(issue.labels.map((label) => label.name));
+  if (issue.state !== 'OPEN') return 'issue is not open';
+  if (issue.assignees.length > 0) return 'issue already has an assignee';
+  const skipped = policy.skipLabels.filter((label) => labels.has(label));
+  if (skipped.length > 0) return `carries ${skipped.join(', ')}`;
+  const missing = policy.requireLabels.filter((label) => !labels.has(label));
+  if (missing.length > 0) return `missing ${missing.join(', ')}`;
+  return null;
+}
+
+// First matching area wins, so file order is the documented precedence.
+export function matchArea(policy, issue) {
+  const labels = new Set(issue.labels.map((label) => label.name));
+  return (
+    policy.areas.find((area) =>
+      area.labels.some((label) => labels.has(label)),
+    ) ?? null
+  );
+}
+
+// Rotate by issue number before the stable minimum so a set of equally loaded
+// owners spreads round-robin instead of always landing on the first entry.
+export function pickOwner(owners, loadByOwner, issueNumber) {
+  const offset = issueNumber % owners.length;
+  const rotated = [...owners.slice(offset), ...owners.slice(0, offset)];
+  return rotated.reduce((best, owner) =>
+    loadByOwner.get(owner) < loadByOwner.get(best) ? owner : best,
+  );
+}
+
+function gh(args) {
+  const result = spawnSync('gh', args, {
+    encoding: 'utf8',
+    maxBuffer: 10 * 1024 * 1024,
+  });
+  if (result.status !== 0) {
+    throw new Error(result.stderr.trim() || `gh ${args.join(' ')} failed`);
+  }
+  return result.stdout.trim();
+}
+
+function record(lines) {
+  const body = `${lines.join('\n')}\n`;
+  process.stdout.write(body);
+  if (process.env.GITHUB_STEP_SUMMARY) {
+    appendFileSync(process.env.GITHUB_STEP_SUMMARY, body);
+  }
+}
+
+// A candidate who lost push access, renamed, or deleted their account makes
+// the permission lookup fail; warn and drop them rather than failing the run
+// over one stale entry.
+function canWrite(repository, login) {
+  try {
+    return WRITE_PERMISSIONS.has(
+      gh([
+        'api',
+        `repos/${repository}/collaborators/${login}/permission`,
+        '--jq',
+        '.permission',
+      ]),
+    );
+  } catch (error) {
+    console.warn(
+      `::warning::Cannot verify push access for @${login}: ${error.message}`,
+    );
+    return false;
+  }
+}
+
+function openIssueCount(repository, login) {
+  return Number(
+    gh([
+      'issue',
+      'list',
+      '--repo',
+      repository,
+      '--state',
+      'open',
+      '--assignee',
+      login,
+      '--limit',
+      '100',
+      '--json',
+      'number',
+      '--jq',
+      'length',
+    ]),
+  );
+}
+
+function main() {
+  const repository = process.env.GITHUB_REPOSITORY;
+  const issueNumber = Number(process.env.ISSUE_NUMBER);
+  const dryRun = process.env.DRY_RUN === 'true';
+  if (!repository || !/^[^/]+\/[^/]+$/.test(repository)) {
+    throw new Error('Invalid repository');
+  }
+  if (!Number.isSafeInteger(issueNumber) || issueNumber < 1) {
+    throw new Error('Invalid issue number');
+  }
+
+  const policy = loadPolicy(readFileSync(OWNERS_FILE, 'utf8'));
+  const issue = JSON.parse(
+    gh([
+      'issue',
+      'view',
+      String(issueNumber),
+      '--repo',
+      repository,
+      '--json',
+      'state,labels,assignees',
+    ]),
+  );
+
+  const skip = skipReason(policy, issue);
+  if (skip) {
+    record([`Assignment: skipped — ${skip}`]);
+    return;
+  }
+
+  const area = matchArea(policy, issue);
+  if (!area) {
+    record(['Assignment: skipped — no area label matched']);
+    return;
+  }
+
+  const eligible = area.owners.filter((owner) => canWrite(repository, owner));
+  if (eligible.length === 0) {
+    console.warn(
+      `::warning::No owner of area ${area.name} has push access; check ${OWNERS_FILE}.`,
+    );
+    record([`Assignment: skipped — no eligible owner for area ${area.name}`]);
+    return;
+  }
+
+  const loadByOwner = new Map(
+    eligible.map((owner) => [owner, openIssueCount(repository, owner)]),
+  );
+  const assignee = pickOwner(eligible, loadByOwner, issueNumber);
+
+  if (dryRun) {
+    record([
+      `Area: ${area.name}`,
+      `Assignment: dry-run — would assign @${assignee} (${loadByOwner.get(assignee)} open)`,
+    ]);
+    return;
+  }
+
+  const latestIssue = JSON.parse(
+    gh([
+      'issue',
+      'view',
+      String(issueNumber),
+      '--repo',
+      repository,
+      '--json',
+      'state,labels,assignees',
+    ]),
+  );
+  const latestSkip = skipReason(policy, latestIssue);
+  if (latestSkip) {
+    record([`Assignment: skipped — ${latestSkip}`]);
+    return;
+  }
+  if (matchArea(policy, latestIssue)?.name !== area.name) {
+    record(['Assignment: skipped — issue labels changed']);
+    return;
+  }
+
+  gh([
+    'issue',
+    'edit',
+    String(issueNumber),
+    '--repo',
+    repository,
+    '--add-assignee',
+    assignee,
+  ]);
+  record([
+    `Area: ${area.name}`,
+    `Assignment: assigned @${assignee} (${loadByOwner.get(assignee)} open)`,
+  ]);
+}
+
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(process.argv[1]).href
+) {
+  try {
+    main();
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}