@kody-ade/kody-engine 0.4.224 → 0.4.225

package/dist/executables/preview-health/profile.json

@@ -1,48 +0,0 @@
-{
-  "name": "preview-health",
-  "role": "watch",
-  "kind": "oneshot",
-  "describe": "Scan open PRs and dispatch mechanical preview repairs.",
-  "inputs": [],
-  "claudeCode": {
-    "model": "inherit",
-    "permissionMode": "default",
-    "maxTurns": 0,
-    "maxThinkingTokens": null,
-    "systemPromptAppend": null,
-    "tools": [],
-    "hooks": [],
-    "skills": [],
-    "commands": [],
-    "subagents": [],
-    "plugins": [],
-    "mcpServers": []
-  },
-  "cliTools": [
-    {
-      "name": "gh",
-      "install": {
-        "required": true,
-        "checkCommand": "command -v gh"
-      },
-      "verify": "gh auth status",
-      "usage": "Reads open PRs, reads the CTO trust ledger, dispatches Kody workflows, and posts PR audit/recommendation comments.",
-      "allowedUses": ["pr", "api", "issue", "workflow"]
-    }
-  ],
-  "inputArtifacts": [],
-  "outputArtifacts": [],
-  "scripts": {
-    "preflight": [
-      {
-        "shell": "tick.sh",
-        "with": {
-          "jobsDir": ".kody/duties",
-          "duty": "preview-health"
-        },
-        "timeoutSec": 300
-      }
-    ],
-    "postflight": []
-  }
-}

package/dist/executables/preview-health/tick.sh

@@ -1,319 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-jobs_dir="${1:-.kody/duties}"
-duty="${2:-preview-health}"
-
-export KODY_PREVIEW_HEALTH_JOBS_DIR="$jobs_dir"
-export KODY_PREVIEW_HEALTH_DUTY="$duty"
-
-python3 <<'PY'
-import base64
-import json
-import os
-import re
-import subprocess
-import sys
-from datetime import datetime, timezone
-
-DECISIONS_LABEL = "kody:cto-decisions"
-LEDGER_START = "<!-- kody-cto-decisions:start -->"
-LEDGER_END = "<!-- kody-cto-decisions:end -->"
-VERBS = ("fix-ci", "sync", "resolve")
-AUTO_VERBS = {"resolve"}
-MAX_ACTIONS_PER_TICK = 5
-FAIL_CONCLUSIONS = {"FAILURE", "TIMED_OUT", "ACTION_REQUIRED", "STARTUP_FAILURE"}
-RUNNING_STATUSES = {"IN_PROGRESS", "QUEUED"}
-STALE_THRESHOLD = 10
-STATE_BRANCH = "kody-state"
-
-
-def log(message):
-    print(f"[preview-health] {message}", file=sys.stderr)
-
-
-def now_iso():
-    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
-
-
-def run_gh(args, input_text=None, check=True):
-    result = subprocess.run(
-        ["gh", *args],
-        input=input_text,
-        text=True,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        cwd=os.getcwd(),
-    )
-    if check and result.returncode != 0:
-        raise RuntimeError(result.stderr.strip() or result.stdout.strip() or f"gh {' '.join(args)} failed")
-    return result.stdout
-
-
-def repo_slug():
-    owner = os.environ.get("KODY_CFG_GITHUB_OWNER", "").strip()
-    repo = os.environ.get("KODY_CFG_GITHUB_REPO", "").strip()
-    if owner and repo:
-        return f"{owner}/{repo}"
-    return run_gh(["repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"]).strip()
-
-
-def default_branch(slug):
-    configured = os.environ.get("KODY_CFG_GIT_DEFAULTBRANCH", "").strip()
-    if configured:
-        return configured
-    return run_gh(["repo", "view", slug, "--json", "defaultBranchRef", "--jq", ".defaultBranchRef.name"]).strip()
-
-
-def ensure_state_branch(slug):
-    if run_gh(["api", f"/repos/{slug}/git/ref/heads/{STATE_BRANCH}"], check=False).strip():
-        return
-    branch = default_branch(slug)
-    sha = run_gh(["api", f"/repos/{slug}/git/ref/heads/{branch}", "--jq", ".object.sha"]).strip()
-    payload = json.dumps({"ref": f"refs/heads/{STATE_BRANCH}", "sha": sha})
-    run_gh(["api", "--method", "POST", f"/repos/{slug}/git/refs", "--input", "-"], input_text=payload)
-
-
-def initial_state():
-    return {"version": 1, "rev": 0, "cursor": "seed", "data": {}, "done": False}
-
-
-def load_state(slug, path):
-    result = run_gh(
-        ["api", f"/repos/{slug}/contents/{path}?ref={STATE_BRANCH}"],
-        check=False,
-    )
-    if not result.strip():
-        return {"path": path, "sha": None, "state": initial_state(), "created": True}
-    obj = json.loads(result)
-    raw = base64.b64decode(obj["content"]).decode("utf-8")
-    return {"path": path, "sha": obj.get("sha"), "state": json.loads(raw), "created": False}
-
-
-def state_unchanged(prev, next_state):
-    return (
-        prev.get("cursor") == next_state.get("cursor")
-        and prev.get("done") == next_state.get("done")
-        and prev.get("data") == next_state.get("data")
-    )
-
-
-def save_state(slug, loaded, next_state):
-    if not loaded["created"] and state_unchanged(loaded["state"], next_state):
-        return False
-    ensure_state_branch(slug)
-    body = json.dumps(next_state, indent=2) + "\n"
-    payload = {
-        "message": f"chore(jobs): update state for {os.environ['KODY_PREVIEW_HEALTH_DUTY']} (rev {next_state['rev']})",
-        "content": base64.b64encode(body.encode("utf-8")).decode("ascii"),
-        "branch": STATE_BRANCH,
-    }
-    if loaded.get("sha"):
-        payload["sha"] = loaded["sha"]
-    result = run_gh(
-        ["api", "--method", "PUT", f"/repos/{slug}/contents/{loaded['path']}", "--input", "-"],
-        input_text=json.dumps(payload),
-        check=False,
-    )
-    if result.strip():
-        return True
-    reloaded = load_state(slug, loaded["path"])
-    if not reloaded["created"] and state_unchanged(reloaded["state"], next_state):
-        return False
-    if reloaded.get("sha"):
-        payload["sha"] = reloaded["sha"]
-    else:
-        payload.pop("sha", None)
-    run_gh(["api", "--method", "PUT", f"/repos/{slug}/contents/{loaded['path']}", "--input", "-"], input_text=json.dumps(payload))
-    return True
-
-
-def read_ledger_modes():
-    modes = {verb: "ask" for verb in VERBS}
-    try:
-        raw = run_gh(["issue", "list", "--label", DECISIONS_LABEL, "--state", "open", "--limit", "20", "--json", "number,body"])
-        issues = json.loads(raw or "[]")
-        if not issues:
-            return modes
-        body = sorted(issues, key=lambda x: x.get("number", 10**9))[0].get("body", "")
-        if LEDGER_START not in body or LEDGER_END not in body:
-            return modes
-        inner = body.split(LEDGER_START, 1)[1].split(LEDGER_END, 1)[0]
-        match = re.search(r"```(?:json)?\s*(\{[\s\S]*?\})\s*```", inner)
-        if not match:
-            return modes
-        ledger = json.loads(match.group(1))
-        cto = ledger.get("staff", {}).get("cto", {})
-        for verb in VERBS:
-            if cto.get(verb, {}).get("mode") == "auto":
-                modes[verb] = "auto"
-    except Exception as err:
-        log(f"ledger read failed; treating all verbs as ask: {err}")
-    return modes
-
-
-def ci_failing(rollup):
-    if not isinstance(rollup, list):
-        return False
-    has_fail = any(str(check.get("conclusion", "")) in FAIL_CONCLUSIONS for check in rollup if isinstance(check, dict))
-    running = any(str(check.get("status", "")) in RUNNING_STATUSES for check in rollup if isinstance(check, dict))
-    return has_fail and not running
-
-
-def behind_by(slug, base, head):
-    try:
-        raw = run_gh(["api", f"repos/{slug}/compare/{base}...{head}", "--jq", ".behind_by"])
-        return int(raw.strip() or "0")
-    except Exception as err:
-        log(f"compare {base}...{head} failed: {err}")
-        return 0
-
-
-def detect_repair(slug, pr):
-    mergeable = str(pr.get("mergeable") or "").upper()
-    if mergeable == "UNKNOWN":
-        return ("defer", f"PR #{pr['number']} mergeability still UNKNOWN; retry next tick.")
-    if mergeable == "CONFLICTING":
-        return ("resolve", f"PR #{pr['number']} has merge conflicts with `{pr['baseRefName']}`.")
-    if ci_failing(pr.get("statusCheckRollup")):
-        return ("fix-ci", f"PR #{pr['number']} has failing CI checks.")
-    drift = behind_by(slug, pr["baseRefName"], pr["headRefName"])
-    if drift >= STALE_THRESHOLD:
-        return ("sync", f"PR #{pr['number']}'s branch is {drift} commits behind `{pr['baseRefName']}`.")
-    return None
-
-
-def duty_operator(jobs_dir, duty):
-    try:
-        with open(os.path.join(os.getcwd(), jobs_dir, duty, "profile.json"), "r", encoding="utf-8") as f:
-            profile = json.load(f)
-        mentions = profile.get("mentions", [])
-        return mentions[0] if isinstance(mentions, list) and mentions else ""
-    except Exception:
-        return ""
-
-
-def post_comment(pr_number, body):
-    if os.environ.get("KODY_DRY_RUN") == "1":
-        log(f"[dry-run] would comment on #{pr_number}: {body.splitlines()[0]}")
-        return True
-    try:
-        run_gh(["pr", "comment", str(pr_number), "--body", body])
-        return True
-    except Exception as err:
-        log(f"comment failed on #{pr_number}: {err}")
-        return False
-
-
-def recommend(pr_number, verb, reason, operator):
-    mention = f"@{operator} " if operator else ""
-    body = (
-        f"{mention}**CTO recommendation** - `{verb}`\n\n"
-        f"{reason} Recommended action: `{verb}` for PR #{pr_number}.\n\n"
-        "_Confirm in dashboard inbox or run the action manually. CTO will not act on its own._"
-    )
-    return post_comment(pr_number, body)
-
-
-def auto_run(pr_number, verb, reason):
-    if os.environ.get("KODY_DRY_RUN") == "1":
-        log(f"[dry-run] would dispatch kody.yml executable={verb} issue_number={pr_number}")
-    else:
-        try:
-            run_gh(["workflow", "run", "kody.yml", "-f", f"executable={verb}", "-f", f"issue_number={pr_number}"])
-        except Exception as err:
-            log(f"workflow_dispatch failed #{pr_number} ({verb}): {err}")
-            return False
-    auto_reason = (
-        "Policy: preview-health auto-runs `resolve` for merge conflicts."
-        if verb in AUTO_VERBS
-        else f"Graduated: operator approved `{verb}` repeatedly. A **Reject** on any `{verb}` returns me asking."
-    )
-    return post_comment(pr_number, f"**CTO action** - `{verb}` dispatched\n\n{reason}\n\n{auto_reason}")
-
-
-def print_row(pr, verb, fp, action, note):
-    print(f"| #{pr} | {verb} | {fp} | {action} | {note} |")
-
-
-def main():
-    slug = repo_slug()
-    jobs_dir = os.environ["KODY_PREVIEW_HEALTH_JOBS_DIR"].rstrip("/")
-    duty = os.environ["KODY_PREVIEW_HEALTH_DUTY"]
-    state_path = f"{jobs_dir}/{duty}/state.json"
-    loaded = load_state(slug, state_path)
-    modes = read_ledger_modes()
-    operator = duty_operator(jobs_dir, duty)
-
-    prs = json.loads(
-        run_gh([
-            "pr",
-            "list",
-            "--state",
-            "open",
-            "--limit",
-            "100",
-            "--json",
-            "number,title,headRefName,headRefOid,baseRefName,isDraft,mergeable,statusCheckRollup,updatedAt",
-        ])
-        or "[]"
-    )
-
-    prior = loaded["state"].get("data", {}).get("prs", {})
-    open_numbers = {str(pr["number"]) for pr in prs}
-    next_prs = {key: value for key, value in prior.items() if key in open_numbers and isinstance(value, dict)}
-
-    print("| PR | verb | fingerprint | action | note |")
-    print("|----|------|-------------|--------|------|")
-
-    priority = {"resolve": 0, "fix-ci": 1, "sync": 2}
-    queue = []
-    for pr in prs:
-        if pr.get("isDraft"):
-            print_row(pr["number"], "-", "-", "skip", "draft")
-            continue
-        repair = detect_repair(slug, pr)
-        if not repair:
-            print_row(pr["number"], "-", "-", "skip", "healthy")
-            continue
-        verb, reason = repair
-        if verb == "defer":
-            print_row(pr["number"], "-", "-", "defer", "mergeable=UNKNOWN")
-            continue
-        queue.append((priority[verb], pr["number"], pr, verb, reason))
-
-    actions_taken = 0
-    for _, number, pr, verb, reason in sorted(queue):
-        key = str(number)
-        fp = f"{verb}|{pr.get('headRefOid', '')}"
-        graduated = verb in AUTO_VERBS or modes.get(verb) == "auto"
-        intended_stage = f"{verb}-auto" if graduated else f"{verb}-recommended"
-        prev = next_prs.get(key, {})
-        if prev.get("fp") == fp and prev.get("stage") == intended_stage:
-            print_row(number, verb, fp[:24], "skip", "dedup")
-            continue
-        if actions_taken >= MAX_ACTIONS_PER_TICK:
-            print_row(number, verb, fp[:24], "defer", "tick cap")
-            continue
-
-        ok = auto_run(number, verb, reason) if graduated else recommend(number, verb, reason, operator)
-        action = "auto-ran" if graduated and ok else "auto-failed" if graduated else "recommended" if ok else "recommend-failed"
-        if ok:
-            actions_taken += 1
-            next_prs[key] = {"fp": fp, "stage": intended_stage, "lastActAt": now_iso()}
-        print_row(number, verb, fp[:24], action, "auto" if graduated else "advisory")
-
-    next_state = {
-        "version": 1,
-        "rev": int(loaded["state"].get("rev", 0)) + 1,
-        "cursor": "idle",
-        "data": {"prs": next_prs, "lastFiredAt": now_iso()},
-        "done": False,
-    }
-    save_state(slug, loaded, next_state)
-    log(f"tick complete: {actions_taken} action(s), {len(next_prs)} tracked PR(s)")
-    print("KODY_SKIP_AGENT=true")
-
-
-main()
-PY

package/dist/executables/probe-skill/profile.json

@@ -1,35 +0,0 @@
-{
-  "name": "probe-skill",
-  "role": "utility",
-  "describe": "Live-test executable. Loads the executable-local 'probe-skill-marker' skill (resolved from src/executables/probe-skill/skills/, NOT the central catalog) and asks the agent to emit the skill's token back as an issue comment. Validates the new local-skill resolution path in buildSyntheticPlugin end-to-end.",
-  "inputs": [
-    { "name": "issue", "flag": "--issue", "type": "int", "required": true, "describe": "GitHub issue number to verify against." }
-  ],
-  "claudeCode": {
-    "model": "inherit",
-    "permissionMode": "default",
-    "maxTurns": 12,
-    "systemPromptAppend": "You are running Kody's executable-local skill live verification. Emit the token exactly as the skill instructs.",
-    "tools": ["Read", "Grep", "Glob", "Bash"],
-    "hooks": [],
-    "skills": ["probe-skill-marker"],
-    "commands": [],
-    "subagents": [],
-    "plugins": [],
-    "mcpServers": []
-  },
-  "cliTools": [],
-  "scripts": {
-    "preflight": [
-      { "script": "loadIssueContext" },
-      { "script": "loadTaskState" },
-      { "script": "buildSyntheticPlugin" },
-      { "script": "composePrompt" }
-    ],
-    "postflight": [
-      { "script": "parseAgentResult" },
-      { "script": "writeRunSummary" },
-      { "script": "saveTaskState" }
-    ]
-  }
-}

package/dist/executables/probe-skill/prompt.md

@@ -1,31 +0,0 @@
-You are Kody's executable-local skill live verification agent. Your only job: prove that the skill named `probe-skill-marker` was loaded into your session from this executable's own directory (NOT the shared catalog), and report its token back to the issue.
-
-Issue #{{issue.number}}: {{issue.title}}
-
----
-
-# What to do
-
-1. List your available skills. Confirm a skill named `probe-skill-marker` is loaded.
-2. Activate it (its activation phrase is "probe-skill-marker"). The skill instructs you to emit a single token of the form `PROBE_SKILL_OK_<version>`.
-3. Post a comment on issue #{{issue.number}} via `gh issue comment {{issue.number}} --body "..."`. The body must be a single line:
-   ```
-   probe-skill verification: <TOKEN>
-   ```
-   Replace `<TOKEN>` with whatever exact token the skill told you to emit. If the skill is NOT loaded, post `probe-skill verification: SKILL_NOT_LOADED` instead.
-
-# Output contract
-
-After posting the comment, your final message must be exactly:
-
-```
-DONE
-COMMIT_MSG: probe-skill: live verification for #{{issue.number}}
-PR_SUMMARY: probe-skill ran; see issue comment for the token.
-```
-
-# Rules
-
-- Read-only on the repo. Do NOT edit any file. Do NOT run git.
-- The only state-changing command you may run is `gh issue comment`.
-- Do not perform the issue's actual work.

package/dist/executables/probe-skill/skills/probe-skill-marker/SKILL.md

@@ -1,18 +0,0 @@
----
-name: probe-skill-marker
-description: Internal Kody live-test skill, shipped from the probe-skill executable's own directory (not the shared src/plugins catalog). Activates when a prompt mentions "probe-skill-marker" and provides a versioned confirmation token.
----
-
-# probe-skill-marker
-
-This skill exists only to verify that Kody's executable-local plugin-part resolution actually loads skills from `src/executables/<name>/skills/` into the agent's session.
-
-## When to activate
-
-When the user's prompt contains the phrase "probe-skill-marker" or explicitly asks whether the skill is loaded.
-
-## What to do
-
-Emit the literal token `PROBE_SKILL_OK_v1` exactly as written. Do not modify, paraphrase, or interpret it. The token version (`v1`) lets us prove that edits to this file are picked up on the next run — bumping it to `v2` here should result in the agent reporting `PROBE_SKILL_OK_v2` after a fresh publish + trigger.
-
-Do not use this skill for anything else. It is a no-op confirmation signal for infrastructure validation.

package/dist/executables/qa-goal/profile.json

@@ -1,65 +0,0 @@
-{
-  "name": "qa-goal",
-  "role": "primitive",
-  "kind": "oneshot",
-  "describe": "Operator-gated half of QA: promotes a QA report (already posted on an issue by qa-engineer) into a goal — manifest entry + one fix-ticket per finding + a committed .kody/goals/<id>/state.json. Deterministic, no agent. The qa / qa-sweep duties surface a `@kody qa-goal --issue <n>` inbox rec; this runs when the operator approves it, so QA never auto-creates goals on its own.",
-  "inputs": [
-    {
-      "name": "issue",
-      "flag": "--issue",
-      "type": "int",
-      "required": true,
-      "describe": "Issue number carrying qa-engineer's QA report (the comment with the <!-- KODY_QA_REPORT_JSON --> block)."
-    },
-    {
-      "name": "scope",
-      "flag": "--scope",
-      "type": "string",
-      "required": false,
-      "describe": "Optional scope label for the goal name (e.g. the changelog entry title). Defaults to 'smoke'."
-    },
-    {
-      "name": "goal",
-      "flag": "--goal",
-      "type": "string",
-      "required": false,
-      "describe": "Optional existing goal id to attach findings to instead of creating a new one."
-    }
-  ],
-  "claudeCode": {
-    "model": "inherit",
-    "permissionMode": "default",
-    "maxTurns": null,
-    "maxThinkingTokens": null,
-    "systemPromptAppend": null,
-    "tools": [],
-    "hooks": [],
-    "skills": [],
-    "commands": [],
-    "subagents": [],
-    "plugins": [],
-    "mcpServers": []
-  },
-  "cliTools": [
-    {
-      "name": "gh",
-      "install": {
-        "required": true,
-        "checkCommand": "command -v gh"
-      },
-      "verify": "gh auth status",
-      "usage": "Reads the QA report (`gh issue view --json comments`), appends to the goals manifest, and opens fix-ticket issues.",
-      "allowedUses": ["issue", "api"]
-    }
-  ],
-  "inputArtifacts": [],
-  "outputArtifacts": [],
-  "scripts": {
-    "preflight": [
-      {
-        "script": "promoteQaGoal"
-      }
-    ],
-    "postflight": []
-  }
-}

package/dist/executables/release/deploy.sh

@@ -1,157 +0,0 @@
-#!/usr/bin/env bash
-#
-# release/deploy.sh — function library for the deploy phase.
-#
-# Functions:
-#   read_changelog_section <branch> <ver>   -> prints the body of the matching ## header block
-#   build_pr_body <ver> <changelog> <default_branch> <release_branch> <issue>
-#                                            -> echoes the deploy PR body
-#   open_deploy_pr <new_version> <issue>    -> echoes deploy PR URL (or empty if no-op)
-
-# shellcheck disable=SC2148
-
-# Extract the section for $ver from CHANGELOG.md fetched from origin/$branch.
-# Handles three header shapes:
-#   "## [0.25.0] - 2026-04-15"   (bracketed, dash separator)
-#   "## 0.22.0 (2026-03-25)"     (bare, parenthesized date)
-#   "## v0.25.5 — 2026-05-05"    (v-prefixed, em-dash, kody style)
-read_changelog_section() {
-  local branch="$1" ver="$2" raw=""
-  if ! raw=$(git show "origin/${branch}:CHANGELOG.md" 2>/dev/null); then
-    return 0
-  fi
-  printf '%s' "$raw" | awk -v ver="$ver" '
-    BEGIN { capture = 0 }
-    /^##[[:space:]]/ {
-      if (capture) { exit }
-      header = $0
-      sub(/^##[[:space:]]+/, "", header)
-      sub(/^\[/, "", header); sub(/\].*/, "", header)
-      sub(/[[:space:]].*/, "", header)
-      sub(/[(].*/, "", header)
-      sub(/^v/, "", header)
-      if (header == ver) { capture = 1; next }
-    }
-    capture { print }
-  ' | awk '
-    NF { if (!started) started = 1; out[++n] = $0; last = n; next }
-    started { out[++n] = $0 }
-    END { for (i = 1; i <= last; i++) print out[i] }
-  '
-}
-
-build_pr_body() {
-  local ver="$1" changelog="$2" default_branch="$3" release_branch="$4" issue="$5"
-  printf 'Automated deploy PR opened by kody — promotes `%s` to `%s` for release **v%s**.\n\n' \
-    "$default_branch" "$release_branch" "$ver"
-  if [[ -n "$changelog" ]]; then
-    printf '<!-- kody-changelog-start -->\n## What'\''s changing in v%s\n\n%s\n<!-- kody-changelog-end -->\n\n' \
-      "$ver" "$changelog"
-  fi
-  printf 'Merge this PR to deploy v%s to `%s`.' "$ver" "$release_branch"
-  if [[ "$issue" =~ ^[0-9]+$ && "$issue" != "0" ]]; then
-    printf '\n\nTracking-Issue: #%s\n' "$issue"
-  else
-    printf '\n'
-  fi
-}
-
-# Open or reuse the deploy PR (default_branch → release_branch).
-# Returns the PR URL via stdout. Empty stdout = single-branch repo, no-op.
-# Refreshes existing PR's body via gh pr edit (idempotent).
-open_deploy_pr() {
-  local new_version="$1"
-  local issue_arg="$2"
-  local default_branch="${KODY_CFG_GIT_DEFAULTBRANCH:-main}"
-  local release_branch="${KODY_CFG_RELEASE_RELEASEBRANCH:-}"
-
-  # Single-branch repos: nothing to deploy.
-  if [[ -z "$release_branch" || "$release_branch" == "$default_branch" ]]; then
-    echo "[deploy] no releaseBranch configured (or equals defaultBranch) — skipping deploy PR" >&2
-    echo ""
-    return 0
-  fi
-
-  # Read the section from the integration branch (where release-prepare just merged).
-  local changelog_section
-  changelog_section=$(read_changelog_section "$default_branch" "$new_version" || true)
-  if [[ -z "$changelog_section" ]]; then
-    echo "[deploy] no CHANGELOG section for v${new_version} on origin/${default_branch} — minimal body" >&2
-  fi
-
-  local body
-  body=$(build_pr_body "$new_version" "$changelog_section" "$default_branch" "$release_branch" "$issue_arg")
-
-  # GitHub rejects a PR body over 65536 chars (GraphQL createPullRequest).
-  # A large accumulated CHANGELOG section can blow past it, so clamp: drop the
-  # changelog to a budget and rebuild, then hard-truncate as a final guard.
-  local body_max=65000
-  if (( ${#body} > body_max )); then
-    echo "[deploy] PR body ${#body} chars > ${body_max} — truncating changelog" >&2
-    local budget=$(( body_max - 2000 ))
-    changelog_section="${changelog_section:0:budget}"$'\n\n_…changelog truncated; see CHANGELOG.md on the branch._'
-    body=$(build_pr_body "$new_version" "$changelog_section" "$default_branch" "$release_branch" "$issue_arg")
-    (( ${#body} > body_max )) && body="${body:0:body_max}"
-  fi
-
-  # Idempotency: reuse an open PR for this branch pair if one exists.
-  local existing pr_url
-  existing=$(gh pr list --head "$default_branch" --base "$release_branch" --state open --json url --limit 1 2>/dev/null \
-    | python3 -c 'import json,sys; data=json.load(sys.stdin); print(data[0]["url"] if data else "")' 2>/dev/null \
-    || echo "")
-
-  if [[ -n "$existing" ]]; then
-    echo "  reusing existing deploy PR: ${existing}" >&2
-    pr_url="$existing"
-    # Refresh body via REST API instead of `gh pr edit` — gh's edit path
-    # uses GraphQL which requires read:org scope on KODY_TOKEN. REST PATCH
-    # works with plain `repo` scope.
-    local pr_num="${pr_url##*/}"
-    local owner="${KODY_CFG_GITHUB_OWNER:-}"
-    local repo="${KODY_CFG_GITHUB_REPO:-}"
-    if [[ -z "$owner" || -z "$repo" ]]; then
-      # Fall back to extracting from the URL if config missing.
-      local stripped="${pr_url#https://github.com/}"
-      owner="${stripped%%/*}"
-      repo=$(echo "$stripped" | cut -d/ -f2)
-    fi
-    local edit_err
-    local refreshed_title="deploy: ${default_branch} → ${release_branch} (v${new_version})"
-    if ! edit_err=$(gh api --method PATCH "repos/${owner}/${repo}/pulls/${pr_num}" \
-        -f title="$refreshed_title" \
-        -f body="$body" 2>&1 >/dev/null); then
-      echo "[deploy] WARN: failed to refresh deploy PR title+body for ${pr_url}: ${edit_err}" >&2
-    else
-      echo "  refreshed deploy PR title + body via REST" >&2
-    fi
-  else
-    if ! pr_url=$(printf '%s' "$body" | gh pr create --head "$default_branch" --base "$release_branch" --title "deploy: ${default_branch} → ${release_branch} (v${new_version})" --body-file -); then
-      echo "[deploy] gh pr create failed" >&2
-      return 1
-    fi
-  fi
-
-  if [[ -z "$pr_url" ]]; then
-    echo "[deploy] empty PR URL after gh pr create" >&2
-    return 1
-  fi
-
-  # Persist the deploy-PR marker on the originating issue body, replacing
-  # any prepare-PR marker so the dashboard pivots to the deploy PR.
-  if [[ "$issue_arg" =~ ^[0-9]+$ && "$issue_arg" != "0" ]]; then
-    local pr_number="${pr_url##*/}"
-    if [[ "$pr_number" =~ ^[0-9]+$ ]]; then
-      local cur_body cleaned_body
-      cur_body=$(gh issue view "$issue_arg" --json body -q .body 2>/dev/null || echo "")
-      cleaned_body=$(printf '%s' "$cur_body" | sed -E '/<!-- kody-release-pr:[^>]*-->/d')
-      {
-        printf '%s' "$cleaned_body"
-        printf '\n\n<!-- kody-release-pr: #%s -->\n' "$pr_number"
-      } | gh issue edit "$issue_arg" --body-file - >/dev/null 2>&1 || \
-        echo "[deploy] WARN: failed to write kody-release-pr marker to issue #${issue_arg}" >&2
-    fi
-  fi
-
-  echo "$pr_url"
-  return 0
-}