agent-control-plane 0.1.0

package/tools/bin/sync-agent-repo.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=/dev/null
+source "${SCRIPT_DIR}/flow-config-lib.sh"
+
+CONFIG_YAML="$(resolve_flow_config_yaml "${BASH_SOURCE[0]}")"
+SOURCE_REPO_ROOT="${ACP_SOURCE_REPO_ROOT:-${F_LOSNING_SOURCE_REPO_ROOT:-$(flow_resolve_retained_repo_root "${CONFIG_YAML}")}}"
+CANONICAL_REPO_ROOT="$(flow_resolve_repo_root "${CONFIG_YAML}")"
+AGENT_REPO_ROOT="$(flow_resolve_agent_repo_root "${CONFIG_YAML}")"
+DEFAULT_BRANCH="$(flow_resolve_default_branch "${CONFIG_YAML}")"
+REMOTE_NAME="${ACP_REMOTE_NAME:-${F_LOSNING_REMOTE_NAME:-origin}}"
+FLOW_SKILL_DIR="$(resolve_flow_skill_dir "${BASH_SOURCE[0]}")"
+FLOW_TOOLS_DIR="${FLOW_SKILL_DIR}/tools/bin"
+
+is_git_checkout() {
+  local repo_root="${1:-}"
+  [[ -n "$repo_root" ]] || return 1
+  [[ -d "$repo_root/.git" || -f "$repo_root/.git" ]]
+}
+
+has_remote() {
+  local repo_root="${1:-}"
+  [[ -n "$repo_root" ]] || return 1
+  git -C "$repo_root" remote get-url "$REMOTE_NAME" >/dev/null 2>&1
+}
+
+SYNC_SEED_ROOT="$AGENT_REPO_ROOT"
+if ! is_git_checkout "$SYNC_SEED_ROOT" || ! has_remote "$SYNC_SEED_ROOT"; then
+  SYNC_SEED_ROOT="$CANONICAL_REPO_ROOT"
+fi
+
+if ! is_git_checkout "$SYNC_SEED_ROOT" || ! has_remote "$SYNC_SEED_ROOT"; then
+  SYNC_SEED_ROOT="$SOURCE_REPO_ROOT"
+fi
+
+if ! is_git_checkout "$SYNC_SEED_ROOT"; then
+  echo "[sync-agent-repo] source repo is not a Git checkout: $SYNC_SEED_ROOT" >&2
+  exit 1
+fi
+
+if ! has_remote "$SYNC_SEED_ROOT"; then
+  echo "[sync-agent-repo] missing remote '$REMOTE_NAME' in source repo: $SYNC_SEED_ROOT" >&2
+  exit 1
+fi
+
+bash "${FLOW_TOOLS_DIR}/agent-project-sync-anchor-repo" \
+  --canonical-root "$SYNC_SEED_ROOT" \
+  --anchor-root "$AGENT_REPO_ROOT" \
+  --remote "$REMOTE_NAME" \
+  --default-branch "$DEFAULT_BRANCH"

package/tools/bin/sync-dependency-baseline.sh

@@ -0,0 +1,247 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=/dev/null
+source "${SCRIPT_DIR}/flow-config-lib.sh"
+
+CONFIG_YAML="$(resolve_flow_config_yaml "${BASH_SOURCE[0]}")"
+AGENT_REPO_ROOT="$(flow_resolve_agent_repo_root "${CONFIG_YAML}")"
+CANONICAL_REPO_ROOT="$(flow_resolve_repo_root "${CONFIG_YAML}")"
+AGENT_ROOT="$(flow_resolve_agent_root "${CONFIG_YAML}")"
+STATE_ROOT="$(flow_resolve_state_root "${CONFIG_YAML}")"
+LOCK_DIR="${STATE_ROOT}/dependency-baseline.lock"
+PID_FILE="${LOCK_DIR}/pid"
+HASH_FILE="${STATE_ROOT}/dependency-baseline.sha256"
+PACKAGE_MANAGER_BIN="${ACP_PACKAGE_MANAGER_BIN:-${F_LOSNING_PACKAGE_MANAGER_BIN:-pnpm}}"
+WORKSPACE_BUILD_PACKAGES_RAW="${ACP_WORKSPACE_BUILD_PACKAGES:-${F_LOSNING_WORKSPACE_BUILD_PACKAGES:-}}"
+WORKSPACE_BUILD_ARTIFACTS_RAW="${ACP_WORKSPACE_BUILD_ARTIFACTS:-${F_LOSNING_WORKSPACE_BUILD_ARTIFACTS:-}}"
+declare -a WORKSPACE_BUILD_PACKAGES=()
+declare -a WORKSPACE_BUILD_ARTIFACTS=()
+
+usage() {
+  cat <<'USAGE'
+Usage:
+  sync-dependency-baseline.sh [--force]
+
+Ensures the clean automation checkout has a current dependency baseline so
+worker worktrees no longer need to borrow node_modules from the retained human
+checkout.
+USAGE
+}
+
+force="false"
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --force) force="true"; shift ;;
+    --help|-h) usage; exit 0 ;;
+    *) echo "Unknown argument: $1" >&2; usage >&2; exit 1 ;;
+  esac
+done
+
+realpath_safe() {
+  local path_value="${1:-}"
+  [[ -n "$path_value" ]] || return 1
+  python3 - "$path_value" <<'PY'
+import os
+import sys
+print(os.path.realpath(sys.argv[1]))
+PY
+}
+
+split_list() {
+  local raw="${1:-}"
+  local item=""
+
+  [[ -n "$raw" ]] || return 0
+  while IFS= read -r item; do
+    [[ -n "$item" ]] || continue
+    printf '%s\n' "$item"
+  done < <(tr ' ' '\n' <<<"$raw")
+}
+
+discover_workspace_build_packages() {
+  local repo_root="${1:?repo root required}"
+  python3 - "$repo_root" <<'PY'
+from pathlib import Path
+import json
+import sys
+
+repo_root = Path(sys.argv[1])
+packages_root = repo_root / "packages"
+if not packages_root.is_dir():
+    raise SystemExit(0)
+
+for package_json in sorted(packages_root.glob("*/package.json")):
+    try:
+        data = json.loads(package_json.read_text(encoding="utf-8"))
+    except Exception:
+        continue
+    name = data.get("name")
+    if isinstance(name, str) and name.strip():
+        print(name.strip())
+PY
+}
+
+load_workspace_lists() {
+  local item=""
+
+  WORKSPACE_BUILD_PACKAGES=()
+  if [[ -n "$WORKSPACE_BUILD_PACKAGES_RAW" ]]; then
+    while IFS= read -r item; do
+      [[ -n "$item" ]] || continue
+      WORKSPACE_BUILD_PACKAGES+=("$item")
+    done < <(split_list "$WORKSPACE_BUILD_PACKAGES_RAW")
+  else
+    while IFS= read -r item; do
+      [[ -n "$item" ]] || continue
+      WORKSPACE_BUILD_PACKAGES+=("$item")
+    done < <(discover_workspace_build_packages "$CANONICAL_REPO_ROOT")
+  fi
+
+  WORKSPACE_BUILD_ARTIFACTS=()
+  if [[ -n "$WORKSPACE_BUILD_ARTIFACTS_RAW" ]]; then
+    while IFS= read -r item; do
+      [[ -n "$item" ]] || continue
+      WORKSPACE_BUILD_ARTIFACTS+=("$item")
+    done < <(split_list "$WORKSPACE_BUILD_ARTIFACTS_RAW")
+  fi
+}
+
+compute_hash() {
+  local repo_root="${1:?repo root required}"
+  (
+    cd "$repo_root"
+    local files=()
+    local candidate
+    for candidate in package.json pnpm-lock.yaml pnpm-workspace.yaml .npmrc; do
+      [[ -e "$candidate" ]] && files+=("$candidate")
+    done
+    {
+      shasum -a 256 "${files[@]}"
+      git rev-parse HEAD 2>/dev/null || true
+    } | shasum -a 256 | awk '{print $1}'
+  )
+}
+
+baseline_paths_ready() {
+  local repo_root="${1:?repo root required}"
+  local workspace_dir=""
+
+  [[ -e "$repo_root/node_modules" ]] || return 1
+
+  while IFS= read -r workspace_dir; do
+    [[ -n "$workspace_dir" ]] || continue
+    [[ -d "$workspace_dir" ]] || continue
+    [[ -e "$workspace_dir/node_modules" ]] || return 1
+  done < <(
+    find "$repo_root/apps" -mindepth 1 -maxdepth 1 -type d 2>/dev/null || true
+    find "$repo_root/packages" -mindepth 1 -maxdepth 1 -type d 2>/dev/null || true
+  )
+}
+
+workspace_artifacts_ready() {
+  local repo_root="${1:?repo root required}"
+  local artifact=""
+
+  if [[ "${#WORKSPACE_BUILD_ARTIFACTS[@]}" -eq 0 ]]; then
+    return 0
+  fi
+
+  for artifact in "${WORKSPACE_BUILD_ARTIFACTS[@]}"; do
+    [[ -f "${repo_root}/${artifact}" ]] || return 1
+  done
+}
+
+build_workspace_artifacts() {
+  local repo_root="${1:?repo root required}"
+  local build_args=()
+  local pkg=""
+
+  if [[ "${#WORKSPACE_BUILD_PACKAGES[@]}" -eq 0 ]]; then
+    return 0
+  fi
+
+  for pkg in "${WORKSPACE_BUILD_PACKAGES[@]}"; do
+    build_args+=(--filter "$pkg")
+  done
+
+  (
+    cd "$repo_root"
+    CI=1 "$PACKAGE_MANAGER_BIN" "${build_args[@]}" build
+  )
+}
+
+acquire_lock() {
+  mkdir -p "$STATE_ROOT"
+  while ! mkdir "$LOCK_DIR" 2>/dev/null; do
+    if [[ -f "$PID_FILE" ]]; then
+      local existing_pid
+      existing_pid="$(cat "$PID_FILE" 2>/dev/null || true)"
+      if [[ -n "$existing_pid" ]] && ! kill -0 "$existing_pid" 2>/dev/null; then
+        rm -rf "$LOCK_DIR"
+        continue
+      fi
+    else
+      rm -rf "$LOCK_DIR"
+      continue
+    fi
+    sleep 1
+  done
+  printf '%s\n' "$$" >"$PID_FILE"
+}
+
+cleanup() {
+  rm -rf "$LOCK_DIR"
+}
+
+trap cleanup EXIT
+
+CANONICAL_REPO_ROOT="$(realpath_safe "$CANONICAL_REPO_ROOT")"
+if [[ ! -d "$CANONICAL_REPO_ROOT/.git" && ! -f "$CANONICAL_REPO_ROOT/.git" ]]; then
+  echo "canonical checkout is not a Git repo: $CANONICAL_REPO_ROOT" >&2
+  exit 1
+fi
+
+if ! command -v "$PACKAGE_MANAGER_BIN" >/dev/null 2>&1; then
+  echo "missing package manager: $PACKAGE_MANAGER_BIN" >&2
+  exit 1
+fi
+
+load_workspace_lists
+expected_hash="$(compute_hash "$CANONICAL_REPO_ROOT")"
+current_hash="$(cat "$HASH_FILE" 2>/dev/null || true)"
+
+if [[ "$force" != "true" && "$expected_hash" == "$current_hash" ]] && baseline_paths_ready "$CANONICAL_REPO_ROOT" && workspace_artifacts_ready "$CANONICAL_REPO_ROOT"; then
+  printf 'DEPENDENCY_BASELINE=ready\n'
+  printf 'REPO_ROOT=%s\n' "$CANONICAL_REPO_ROOT"
+  printf 'HASH=%s\n' "$expected_hash"
+  exit 0
+fi
+
+acquire_lock
+
+load_workspace_lists
+expected_hash="$(compute_hash "$CANONICAL_REPO_ROOT")"
+current_hash="$(cat "$HASH_FILE" 2>/dev/null || true)"
+if [[ "$force" != "true" && "$expected_hash" == "$current_hash" ]] && baseline_paths_ready "$CANONICAL_REPO_ROOT" && workspace_artifacts_ready "$CANONICAL_REPO_ROOT"; then
+  printf 'DEPENDENCY_BASELINE=ready\n'
+  printf 'REPO_ROOT=%s\n' "$CANONICAL_REPO_ROOT"
+  printf 'HASH=%s\n' "$expected_hash"
+  exit 0
+fi
+
+(
+  cd "$CANONICAL_REPO_ROOT"
+  CI=1 "$PACKAGE_MANAGER_BIN" install --frozen-lockfile --prefer-offline
+)
+
+build_workspace_artifacts "$CANONICAL_REPO_ROOT"
+
+baseline_paths_ready "$CANONICAL_REPO_ROOT"
+workspace_artifacts_ready "$CANONICAL_REPO_ROOT"
+printf '%s\n' "$expected_hash" >"$HASH_FILE"
+
+printf 'DEPENDENCY_BASELINE=updated\n'
+printf 'REPO_ROOT=%s\n' "$CANONICAL_REPO_ROOT"
+printf 'HASH=%s\n' "$expected_hash"

package/tools/bin/sync-pr-labels.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=/dev/null
+source "${SCRIPT_DIR}/flow-shell-lib.sh"
+
+PR_NUMBER="${1:?usage: sync-pr-labels.sh PR_NUMBER}"
+FLOW_SKILL_DIR="$(resolve_flow_skill_dir "${BASH_SOURCE[0]}")"
+ADAPTER_BIN_DIR="${FLOW_SKILL_DIR}/bin"
+
+"${ADAPTER_BIN_DIR}/sync-pr-labels.sh" "$PR_NUMBER"

package/tools/bin/sync-recurring-issue-checklist.sh

@@ -0,0 +1,274 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=/dev/null
+source "${SCRIPT_DIR}/flow-config-lib.sh"
+
+usage() {
+  cat <<'EOF'
+Usage:
+  sync-recurring-issue-checklist.sh --repo-slug <owner/repo> --issue-id <id> [--dry-run]
+
+Best-effort sync of recurring keep-open issue checklist boxes against merged PR
+history referenced from prior "Opened PR #..." issue comments.
+EOF
+}
+
+repo_slug=""
+issue_id=""
+dry_run="false"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --repo-slug) repo_slug="${2:-}"; shift 2 ;;
+    --issue-id) issue_id="${2:-}"; shift 2 ;;
+    --dry-run) dry_run="true"; shift ;;
+    --help|-h) usage; exit 0 ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      usage >&2
+      exit 1
+      ;;
+  esac
+done
+
+if [[ -z "${repo_slug}" || -z "${issue_id}" ]]; then
+  usage >&2
+  exit 1
+fi
+
+issue_json="$(flow_github_issue_view_json "${repo_slug}" "${issue_id}")"
+pr_numbers="$(
+  ISSUE_JSON="${issue_json}" node -e '
+const issue = JSON.parse(process.env.ISSUE_JSON || "{}");
+const seen = new Set();
+const numbers = [];
+for (const comment of issue.comments || []) {
+  const body = String((comment && comment.body) || "");
+  for (const match of body.matchAll(/Opened PR #(\d+)/g)) {
+    const prNumber = String(match[1] || "").trim();
+    if (!prNumber || seen.has(prNumber)) continue;
+    seen.add(prNumber);
+    numbers.push(prNumber);
+  }
+}
+process.stdout.write(numbers.join("\n"));
+'
+)"
+
+pr_jsonl_file="$(mktemp)"
+sync_json_file="$(mktemp)"
+trap 'rm -f "${pr_jsonl_file}" "${sync_json_file}"' EXIT
+
+while IFS= read -r pr_number; do
+  [[ -n "${pr_number}" ]] || continue
+  pr_json="$(flow_github_pr_view_json "${repo_slug}" "${pr_number}" 2>/dev/null || true)"
+  [[ -n "${pr_json}" ]] || continue
+  printf '%s\n' "${pr_json}" >>"${pr_jsonl_file}"
+done <<<"${pr_numbers}"
+
+ISSUE_JSON="${issue_json}" PR_JSONL_FILE="${pr_jsonl_file}" node <<'EOF' >"${sync_json_file}"
+const fs = require('fs');
+
+const issue = JSON.parse(process.env.ISSUE_JSON || '{}');
+const issueBody = String(issue.body || '');
+const prJsonlFile = process.env.PR_JSONL_FILE || '';
+const prs = [];
+
+if (prJsonlFile && fs.existsSync(prJsonlFile)) {
+  const raw = fs.readFileSync(prJsonlFile, 'utf8');
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    prs.push(JSON.parse(trimmed));
+  }
+}
+
+const labels = new Set((issue.labels || []).map((label) => String(label?.name || '')));
+const isRecurring = labels.has('agent-keep-open');
+const lines = issueBody.split(/\r?\n/);
+const checklistPattern = /^(\s*-\s+\[)( |x|X)(\]\s+)(.*)$/;
+const allChecklistCompletedComment = (issue.comments || []).find((comment) =>
+  /^# Blocker: All checklist items already completed\b/m.test(String(comment?.body || '')),
+);
+
+const stopWords = new Set([
+  'a', 'an', 'and', 'are', 'as', 'at', 'be', 'by', 'do', 'does', 'each',
+  'for', 'from', 'if', 'in', 'into', 'is', 'it', 'its', 'now', 'of', 'on',
+  'one', 'only', 'or', 'per', 'so', 'than', 'that', 'the', 'their', 'them',
+  'then', 'this', 'to', 'up', 'with', 'within',
+]);
+
+const splitCamel = (value) =>
+  String(value || '')
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2');
+
+const normalizeWords = (value) =>
+  splitCamel(value)
+    .replace(/[`*_()[\]{}:;,!?/\\]+/g, ' ')
+    .replace(/\.(?=[A-Za-z])/g, ' ')
+    .toLowerCase()
+    .split(/[^a-z0-9-]+/)
+    .map((token) => token.trim())
+    .filter((token) => token.length >= 3 && !stopWords.has(token));
+
+const unique = (items) => [...new Set(items.filter(Boolean))];
+
+const extractCodeTokens = (value) => {
+  const raw = String(value || '');
+  const tokens = [];
+  for (const match of raw.matchAll(/`([^`]+)`/g)) {
+    tokens.push(match[1]);
+  }
+  for (const match of raw.matchAll(/\B--[a-z0-9-]+\b/gi)) {
+    tokens.push(match[0]);
+  }
+  for (const match of raw.matchAll(/\b[a-z][a-z0-9]*(?:[A-Z][a-z0-9]+)+\b/g)) {
+    tokens.push(match[0]);
+  }
+  return unique(
+    tokens.map((token) =>
+      String(token || '')
+        .replace(/[`*_()[\]{}:;,!?/\\]+/g, ' ')
+        .trim()
+        .toLowerCase(),
+    ),
+  );
+};
+
+const mergedPrs = prs.filter((pr) => String(pr.mergedAt || '').trim() || String(pr.state || '').toUpperCase() === 'MERGED');
+
+const buildPrMatcher = (pr) => {
+  const combined = `${pr.title || ''}\n${pr.body || ''}`;
+  return {
+    number: pr.number,
+    combinedLower: combined.toLowerCase(),
+    words: new Set(normalizeWords(combined)),
+    codeTokens: new Set(extractCodeTokens(combined)),
+  };
+};
+
+const prMatchers = mergedPrs.map(buildPrMatcher);
+
+const matchChecklistItem = (itemText) => {
+  const itemWords = unique(normalizeWords(itemText));
+  const itemCodeTokens = unique(extractCodeTokens(itemText));
+  let best = null;
+
+  for (const pr of prMatchers) {
+    const matchedWords = itemWords.filter((word) => pr.words.has(word));
+    const matchedCodeTokens = itemCodeTokens.filter((token) =>
+      pr.codeTokens.has(token) || pr.combinedLower.includes(token),
+    );
+    const wordScore = itemWords.length > 0 ? matchedWords.length / itemWords.length : 0;
+    const codeScore = itemCodeTokens.length > 0 ? matchedCodeTokens.length / itemCodeTokens.length : 0;
+
+    let matched = false;
+    if (itemCodeTokens.length > 0) {
+      matched =
+        (matchedCodeTokens.length > 0 && (codeScore >= 0.5 || wordScore >= 0.35)) ||
+        (matchedWords.length >= 2 && wordScore >= 0.45);
+    } else {
+      matched = matchedWords.length >= 2 && wordScore >= 0.45;
+    }
+
+    if (!matched) continue;
+
+    const candidate = {
+      number: pr.number,
+      wordScore,
+      codeScore,
+      matchedWords: matchedWords.length,
+      matchedCodeTokens: matchedCodeTokens.length,
+    };
+
+    if (
+      !best ||
+      candidate.codeScore > best.codeScore ||
+      candidate.wordScore > best.wordScore ||
+      candidate.matchedWords > best.matchedWords
+    ) {
+      best = candidate;
+    }
+  }
+
+  return best;
+};
+
+const checklistEntries = [];
+const matchedPrNumbers = new Set();
+let changed = false;
+
+const updatedLines = lines.map((line, index) => {
+  const match = line.match(checklistPattern);
+  if (!match) return line;
+
+  const checked = String(match[2] || '').toLowerCase() === 'x';
+  const text = String(match[4] || '');
+  const entry = { index, checked, text, matchedPr: null };
+
+  if (!checked) {
+    if (allChecklistCompletedComment) {
+      changed = true;
+      checklistEntries.push({ ...entry, checked: true, matchedByWorkflowComment: true });
+      return `${match[1]}x${match[3]}${text}`;
+    }
+
+    entry.matchedPr = matchChecklistItem(text);
+    if (entry.matchedPr) {
+      matchedPrNumbers.add(String(entry.matchedPr.number));
+      changed = true;
+      checklistEntries.push({ ...entry, checked: true });
+      return `${match[1]}x${match[3]}${text}`;
+    }
+  }
+
+  checklistEntries.push(entry);
+  return line;
+});
+
+const total = checklistEntries.length;
+const checkedCount = checklistEntries.filter((entry) => entry.checked || entry.matchedPr).length;
+const uncheckedCount = Math.max(total - checkedCount, 0);
+
+let status = 'noop';
+if (!isRecurring) {
+  status = 'skipped-not-recurring';
+} else if (total === 0) {
+  status = 'skipped-no-checklist';
+} else if (changed) {
+  status = 'updated';
+}
+
+const result = {
+  status,
+  total,
+  checked: checkedCount,
+  unchecked: uncheckedCount,
+  changed,
+  matchedPrNumbers: [...matchedPrNumbers],
+  body: changed ? updatedLines.join('\n') : issueBody,
+};
+
+process.stdout.write(`${JSON.stringify(result)}\n`);
+EOF
+
+sync_status="$(jq -r '.status' "${sync_json_file}")"
+total_count="$(jq -r '.total' "${sync_json_file}")"
+checked_count="$(jq -r '.checked' "${sync_json_file}")"
+unchecked_count="$(jq -r '.unchecked' "${sync_json_file}")"
+changed="$(jq -r '.changed' "${sync_json_file}")"
+matched_pr_numbers="$(jq -r '.matchedPrNumbers | join(",")' "${sync_json_file}")"
+
+if [[ "${dry_run}" != "true" && "${changed}" == "true" ]]; then
+  updated_body="$(jq -r '.body' "${sync_json_file}")"
+  flow_github_issue_update_body "${repo_slug}" "${issue_id}" "${updated_body}"
+fi
+
+printf 'CHECKLIST_SYNC_STATUS=%s\n' "${sync_status}"
+printf 'CHECKLIST_TOTAL=%s\n' "${total_count}"
+printf 'CHECKLIST_CHECKED=%s\n' "${checked_count}"
+printf 'CHECKLIST_UNCHECKED=%s\n' "${unchecked_count}"
+printf 'CHECKLIST_MATCHED_PR_NUMBERS=%s\n' "${matched_pr_numbers}"