@kody-ade/kody-engine 0.4.224 → 0.4.226

package/dist/executables/release/release.sh

@@ -1,230 +0,0 @@
-#!/usr/bin/env bash
-#
-# release/release.sh — single-job release driver.
-#
-# Replaces the orchestrator + 3-executable chain with one linear bash flow:
-#   prepare → wait CI → merge → publish → deploy → notify
-#
-# Inputs (env, set by the executor):
-#   KODY_ARG_ISSUE      triggering issue number (required)
-#   KODY_ARG_BUMP       patch|minor|major (default: patch)
-#   KODY_ARG_DRY_RUN    true|false
-#   KODY_ARG_PREFER     ours|theirs (optional; for branch collision)
-#
-# Config (env, flattened from kody.config.json):
-#   KODY_CFG_GIT_DEFAULTBRANCH         e.g. dev
-#   KODY_CFG_RELEASE_RELEASEBRANCH     e.g. main (unset → deploy is no-op)
-#   KODY_CFG_RELEASE_VERSIONFILES      JSON array
-#   KODY_CFG_RELEASE_PUBLISHCOMMAND    optional; $VERSION substituted
-#   KODY_CFG_RELEASE_NOTIFYCOMMAND     optional; $VERSION + $DEPLOY_PR_URL substituted
-#   KODY_CFG_RELEASE_DRAFTRELEASE      "true" → create as draft
-#   KODY_CFG_RELEASE_TIMEOUTMS         per-command timeout in ms
-#
-# Stdout signals:
-#   KODY_PR_URL=<deploy PR url>
-#   KODY_REASON=<text>
-#   KODY_SKIP_AGENT=true
-#   RELEASE_COMPLETED=true | RELEASE_FAILED=true (consumed by recordOutcome → finishFlow)
-
-set -euo pipefail
-
-HERE="$(dirname "$0")"
-# shellcheck source=prepare.sh
-source "$HERE/prepare.sh"
-# shellcheck source=wait.sh
-source "$HERE/wait.sh"
-# shellcheck source=publish.sh
-source "$HERE/publish.sh"
-# shellcheck source=deploy.sh
-source "$HERE/deploy.sh"
-
-issue="${KODY_ARG_ISSUE:?required}"
-bump="${KODY_ARG_BUMP:-patch}"
-dry_run="${KODY_ARG_DRY_RUN:-false}"
-prefer="${KODY_ARG_PREFER:-}"
-
-default_branch="${KODY_CFG_GIT_DEFAULTBRANCH:-main}"
-release_branch="${KODY_CFG_RELEASE_RELEASEBRANCH:-}"
-notify_cmd="${KODY_CFG_RELEASE_NOTIFYCOMMAND:-}"
-notify_timeout_s=$(( ${KODY_CFG_RELEASE_TIMEOUTMS:-600000} / 1000 ))
-
-# Tracks where we were when an error fired, for clearer failure messages.
-current_step="init"
-
-on_error() {
-  local rc=$?
-  echo "[release] FAILED during step '${current_step}' (exit ${rc})" >&2
-  echo "KODY_REASON=release failed during ${current_step}"
-  echo "RELEASE_FAILED=true"
-  echo "KODY_SKIP_AGENT=true"
-  exit "$rc"
-}
-trap on_error ERR
-
-if [[ ! -f package.json ]]; then
-  echo "[release] package.json not found in $(pwd)" >&2
-  echo "KODY_REASON=release: package.json not found"
-  echo "RELEASE_FAILED=true"
-  echo "KODY_SKIP_AGENT=true"
-  exit 1
-fi
-
-read_pkg_version_from_ref() {
-  local ref="$1"
-  git show "${ref}:package.json" 2>/dev/null | node -e 'let s=""; process.stdin.on("data", c => s += c); process.stdin.on("end", () => { try { console.log(JSON.parse(s).version || "") } catch { process.exit(1) } })'
-}
-
-finish_release_with_deploy() {
-  local version="$1"
-  local tag="$2"
-  local release_url="${3:-}"
-
-  current_step="deploy"
-  set +e
-  deploy_pr_url=$(open_deploy_pr "$version" "$issue")
-  deploy_rc=$?
-  set -e
-  if [[ "$deploy_rc" -ne 0 ]]; then
-    echo "[release] deploy step failed (rc=${deploy_rc}) — published v${version} but ${default_branch}→${release_branch} promotion PR was not opened" >&2
-    echo "KODY_REASON=release v${version}: published, but ${default_branch}→${release_branch} deploy PR failed"
-    echo "RELEASE_TAG=${tag}"
-    [[ -n "$release_url" ]] && echo "RELEASE_URL=${release_url}"
-    echo "RELEASE_FAILED=true"
-    exit 1
-  fi
-  if [[ -z "$deploy_pr_url" ]]; then
-    echo " (deploy: no-op — single-branch repo)"
-  else
-    echo "✓ deploy: ${deploy_pr_url}"
-  fi
-
-  current_step="notify"
-  notify_status="skipped"
-  if [[ -n "$notify_cmd" ]]; then
-    cmd="${notify_cmd//\$VERSION/$version}"
-    cmd="${cmd//\$DEPLOY_PR_URL/${deploy_pr_url:-}}"
-    echo " notify: ${cmd}"
-    if timeout "$notify_timeout_s" bash -c "$cmd"; then
-      notify_status="ok"
-    else
-      notify_status="failed"
-      echo "[release] notifyCommand failed (non-fatal)" >&2
-    fi
-  fi
-
-  current_step="done"
-  [[ -n "$deploy_pr_url" ]] && echo "KODY_PR_URL=${deploy_pr_url}"
-  echo "RELEASE_TAG=${tag}"
-  [[ -n "$release_url" ]] && echo "RELEASE_URL=${release_url}"
-  [[ -n "$deploy_pr_url" ]] && echo "RELEASE_DEPLOY_PR=${deploy_pr_url}"
-  echo "KODY_REASON=release v${version} complete (notify=${notify_status})"
-  echo "RELEASE_COMPLETED=true"
-  echo "KODY_SKIP_AGENT=true"
-}
-
-resume_prepared_release_if_needed() {
-  [[ -n "$release_branch" && "$release_branch" != "$default_branch" ]] || return 1
-
-  current_step="resume-check"
-  git fetch origin "$default_branch" "$release_branch" --tags
-
-  local default_version release_version
-  default_version=$(read_pkg_version_from_ref "origin/${default_branch}" || echo "")
-  release_version=$(read_pkg_version_from_ref "origin/${release_branch}" || echo "")
-  [[ -n "$default_version" && -n "$release_version" ]] || return 1
-  [[ "$default_version" != "$release_version" ]] || return 1
-
-  local version="$default_version"
-  local tag="v${version}"
-  echo "→ release: resuming prepared ${tag}; ${default_branch} is not promoted to ${release_branch}"
-
-  current_step="publish"
-  git checkout "$default_branch"
-  git reset --hard "origin/$default_branch"
-
-  local publish_status release_url
-  publish_status=$(tag_and_publish "$version")
-  release_url=$(create_gh_release "$tag" || echo "")
-  echo "✓ publish: tag=${tag} status=${publish_status} release_url=${release_url:-<none>}"
-  if [[ "$publish_status" == "failed" ]]; then
-    echo "[release] publishCommand failed but tag + GH release exist" >&2
-    echo "KODY_REASON=tag + GH release created, but publishCommand failed"
-    echo "RELEASE_FAILED=true"
-    echo "KODY_SKIP_AGENT=true"
-    exit 1
-  fi
-
-  finish_release_with_deploy "$version" "$tag" "$release_url"
-  exit 0
-}
-
-resume_prepared_release_if_needed
-
-# ── 1. Prepare ────────────────────────────────────────────────────────────
-current_step="prepare"
-old_version=$(read_pkg_version)
-new_version=$(bump_version "$old_version" "$bump")
-tag="v${new_version}"
-echo "→ release: issue=#${issue} bump=${bump} ${old_version} → ${new_version}"
-
-if [[ "$dry_run" == "true" ]]; then
-  echo "RELEASE_PLAN=bump=${new_version} tag=${tag}"
-  echo "KODY_REASON=dry-run — would bump to ${new_version}${prefer:+ (--prefer ${prefer})}"
-  echo "RELEASE_COMPLETED=true"
-  echo "KODY_SKIP_AGENT=true"
-  exit 0
-fi
-
-prep_pr_url=$(open_prepare_pr "$new_version" "$issue" "$prefer")
-if [[ -z "$prep_pr_url" ]]; then
-  echo "[release] prepare returned no PR URL" >&2
-  exit 1
-fi
-echo "✓ prepare: ${prep_pr_url}"
-set_kody_release_pr_marker "$issue" "$prep_pr_url"
-
-# ── 2. Wait for prepare PR CI ─────────────────────────────────────────────
-current_step="wait_prepare_ci"
-prep_pr_num="${prep_pr_url##*/}"
-wait_for_ci "$prep_pr_num" 60 || {
-  echo "[release] CI failed/timeout on prepare PR #${prep_pr_num}" >&2
-  exit 1
-}
-
-# ── 3. Merge prepare PR ───────────────────────────────────────────────────
-current_step="merge"
-if gh pr merge "$prep_pr_num" --merge --admin 2>&1; then
-  echo "✓ merged: PR #${prep_pr_num}"
-elif gh pr merge "$prep_pr_num" --merge 2>&1 | grep -qi "already merged"; then
-  echo "  (already merged)"
-else
-  echo "[release] gh pr merge failed for PR #${prep_pr_num}" >&2
-  exit 1
-fi
-
-# ── 4. Publish (tag + GH release) ─────────────────────────────────────────
-current_step="publish"
-git fetch origin "$default_branch" --tags
-git checkout "$default_branch"
-git reset --hard "origin/$default_branch"
-
-# Sanity: confirm the bump landed on the integration branch.
-landed_version=$(read_pkg_version)
-if [[ "$landed_version" != "$new_version" ]]; then
-  echo "[release] WARN: package.json on ${default_branch} is ${landed_version}, expected ${new_version} after merge" >&2
-fi
-
-publish_status=$(tag_and_publish "$new_version")
-release_url=$(create_gh_release "$tag" || echo "")
-echo "✓ publish: tag=${tag} status=${publish_status} release_url=${release_url:-<none>}"
-
-if [[ "$publish_status" == "failed" ]]; then
-  echo "[release] publishCommand failed but tag + GH release exist" >&2
-  echo "KODY_REASON=tag + GH release created, but publishCommand failed"
-  echo "RELEASE_FAILED=true"
-  echo "KODY_SKIP_AGENT=true"
-  exit 1
-fi
-
-finish_release_with_deploy "$new_version" "$tag" "$release_url"
-exit 0

package/dist/executables/release/wait.sh

@@ -1,88 +0,0 @@
-#!/usr/bin/env bash
-#
-# release/wait.sh — wait_for_ci function: poll a PR's check rollup
-# until all non-skipped checks pass, or timeout.
-#
-# Function: wait_for_ci <pr_number> <timeout_minutes> [poll_seconds] [initial_wait]
-# Returns 0 on CI passed, 1 on CI failed/timeout.
-#
-# Special-case: if a PR has zero registered checks (no CI configured),
-# treats that as PASSED after a short stabilization window — so a Tester
-# repo without checks doesn't loop forever.
-
-# shellcheck disable=SC2148
-
-wait_for_ci() {
-  local pr_number="$1"
-  local timeout_minutes="${2:-60}"
-  local poll_seconds="${3:-30}"
-  local initial_wait="${4:-15}"
-
-  if [[ -z "$pr_number" || ! "$pr_number" =~ ^[0-9]+$ ]]; then
-    echo "[wait_for_ci] invalid pr_number: '$pr_number'" >&2
-    return 1
-  fi
-
-  local deadline=$(( $(date +%s) + timeout_minutes * 60 ))
-  echo "→ wait_for_ci: PR #${pr_number}, timeout=${timeout_minutes}m"
-
-  sleep "$initial_wait"
-
-  # Track consecutive "no checks" results so we don't bail prematurely
-  # on a PR that's just slow to register checks.
-  local empty_count=0
-  local empty_threshold=4   # ~2 minutes (4 * poll_seconds=30s) before treating as no-CI
-
-  while (( $(date +%s) < deadline )); do
-    local raw
-    if ! raw=$(gh pr checks "$pr_number" --json state 2>/dev/null); then
-      # gh exits non-zero when there are no checks — treat as no-CI.
-      empty_count=$((empty_count + 1))
-      echo "  [wait_for_ci] gh pr checks returned non-zero (count=${empty_count})"
-      if (( empty_count >= empty_threshold )); then
-        echo "→ wait_for_ci: PR #${pr_number} has no CI checks configured — treating as passed"
-        return 0
-      fi
-      sleep "$poll_seconds"
-      continue
-    fi
-
-    # Empty array? Same path.
-    local total
-    total=$(printf '%s' "$raw" | jq 'length' 2>/dev/null || echo "0")
-    if [[ "$total" == "0" ]]; then
-      empty_count=$((empty_count + 1))
-      echo "  [wait_for_ci] no checks registered yet (count=${empty_count})"
-      if (( empty_count >= empty_threshold )); then
-        echo "→ wait_for_ci: PR #${pr_number} has no CI checks configured — treating as passed"
-        return 0
-      fi
-      sleep "$poll_seconds"
-      continue
-    fi
-    empty_count=0
-
-    # Tally states via jq.
-    local pending failed passed failed_names
-    pending=$(printf '%s' "$raw" | jq '[.[] | select((.state // "") | IN("PENDING","IN_PROGRESS","QUEUED",""))] | length')
-    failed=$(printf '%s' "$raw" | jq '[.[] | select((.state // "") | IN("FAILURE","CANCELLED","TIMED_OUT","ACTION_REQUIRED","STARTUP_FAILURE"))] | length')
-    passed=$(printf '%s' "$raw" | jq '[.[] | select((.state // "") | IN("SUCCESS","SKIPPED","NEUTRAL"))] | length')
-    failed_names=$(printf '%s' "$raw" | jq -r '[.[] | select((.state // "") | IN("FAILURE","CANCELLED","TIMED_OUT","ACTION_REQUIRED","STARTUP_FAILURE")) | .name] | join(",")')
-
-    echo "  [wait_for_ci] pending=${pending} passed=${passed} failed=${failed} (total=${total})"
-
-    if [[ "$failed" -gt 0 ]]; then
-      echo "[wait_for_ci] CI failed on PR #${pr_number}: ${failed_names}" >&2
-      return 1
-    fi
-    if [[ "$pending" -eq 0 && "$passed" -gt 0 ]]; then
-      echo "→ wait_for_ci: all checks passed (${passed}) on PR #${pr_number}"
-      return 0
-    fi
-
-    sleep "$poll_seconds"
-  done
-
-  echo "[wait_for_ci] timeout after ${timeout_minutes}m on PR #${pr_number}" >&2
-  return 1
-}

package/dist/executables/release-deploy/deploy.sh

@@ -1,222 +0,0 @@
-#!/usr/bin/env bash
-#
-# release-deploy: open a PR from the integration branch (git.defaultBranch)
-# into the production target (release.releaseBranch) — the human gate for
-# production deploy. The orchestrator's chain ENDS with this PR opened;
-# merging it is a manual step. No agent.
-#
-# Behavior:
-#   - If release.releaseBranch is unset OR equals git.defaultBranch:
-#       no-op success (single-branch repos have nothing to deploy).
-#   - Else: idempotently open PR `defaultBranch` → `releaseBranch`. If an
-#     open PR for that pair already exists, reuse its URL.
-#
-# After the PR is opened, runs `release.notifyCommand` (if set) as a
-# best-effort post-deploy hook.
-#
-# Inputs (env):
-#   KODY_ARG_DRY_RUN          true|false
-#   KODY_ARG_ISSUE            triggering issue/PR number (optional)
-#
-# Config (env):
-#   KODY_CFG_GIT_DEFAULTBRANCH         e.g. dev
-#   KODY_CFG_RELEASE_RELEASEBRANCH     e.g. main (unset → no-op)
-#   KODY_CFG_RELEASE_NOTIFYCOMMAND     optional; $VERSION substituted
-#   KODY_CFG_RELEASE_TIMEOUTMS         per-command timeout in ms (default 600000)
-#
-# Stdout signals:
-#   KODY_PR_URL=<deploy PR url>
-#   KODY_REASON=<text>
-#   KODY_SKIP_AGENT=true
-
-set -euo pipefail
-
-dry_run="${KODY_ARG_DRY_RUN:-false}"
-default_branch="${KODY_CFG_GIT_DEFAULTBRANCH:-main}"
-release_branch="${KODY_CFG_RELEASE_RELEASEBRANCH:-}"
-notify_cmd="${KODY_CFG_RELEASE_NOTIFYCOMMAND:-}"
-timeout_ms="${KODY_CFG_RELEASE_TIMEOUTMS:-600000}"
-timeout_s=$((timeout_ms / 1000))
-
-# Read version from the integration branch tip (where the bump commit lives),
-# not from the local working tree (the workflow may have checked out another
-# branch). Falls back to local package.json if the fetch fails.
-read_version() {
-  local branch="$1"
-  if git fetch origin "$branch" --quiet 2>/dev/null; then
-    if pkg=$(git show "origin/${branch}:package.json" 2>/dev/null); then
-      echo "$pkg" | python3 -c "import json,sys; print(json.load(sys.stdin)['version'])" 2>/dev/null && return
-    fi
-  fi
-  python3 -c "import json; print(json.load(open('package.json'))['version'])" 2>/dev/null || echo "unknown"
-}
-
-version=$(read_version "$default_branch")
-echo "→ release deploy: v${version}"
-
-# Read the CHANGELOG section for $version from the integration branch
-# (where release-prepare just committed it). Handles both header shapes
-# observed in the wild: `## [0.25.0] - 2026-04-15` and `## 0.22.0 (...)`.
-# Prints the body lines (without the matched header). Empty stdout =
-# fall back to the minimal PR body — never break the release.
-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 }
-    # Match all observed 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 release-prepare style)
-    /^##[[: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 '
-    # Trim leading and trailing blank lines from the captured block.
-    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] }
-  '
-}
-
-changelog_section=$(read_changelog_section "$default_branch" "$version" || true)
-if [[ -z "$changelog_section" ]]; then
-  echo "  no CHANGELOG section for v${version} on origin/${default_branch} — using minimal PR body"
-fi
-
-# Build the kody-managed body block. A marker pair lets us update the
-# section idempotently on re-runs without clobbering anything a human
-# pasted outside the markers.
-build_pr_body() {
-  local tracking_line="$1"
-  printf 'Automated deploy PR opened by kody — promotes `%s` to `%s` for release **v%s**.\n\n' \
-    "$default_branch" "$release_branch" "$version"
-  if [[ -n "$changelog_section" ]]; then
-    printf '<!-- kody-changelog-start -->\n## What'\''s changing in v%s\n\n%s\n<!-- kody-changelog-end -->\n\n' \
-      "$version" "$changelog_section"
-  fi
-  printf 'Merge this PR to deploy v%s to `%s`.%s\n' \
-    "$version" "$release_branch" "$tracking_line"
-}
-
-# Single-branch repos: nothing to deploy.
-if [[ -z "$release_branch" || "$release_branch" == "$default_branch" ]]; then
-  echo "KODY_REASON=no releaseBranch configured (or equals defaultBranch) — nothing to deploy"
-  echo "KODY_SKIP_AGENT=true"
-  exit 0
-fi
-
-if [[ "$dry_run" == "true" ]]; then
-  echo "KODY_REASON=dry-run — would open PR ${default_branch} → ${release_branch}"
-  echo "KODY_SKIP_AGENT=true"
-  exit 0
-fi
-
-export HUSKY=0 SKIP_HOOKS=1 CI="${CI:-1}"
-
-# Idempotency: reuse an open PR for this branch pair if one exists.
-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 "")
-
-# Hoisted so the kody-release-pr marker write below also runs in the
-# reuse-existing-PR path.
-issue_arg="${KODY_ARG_ISSUE:-}"
-
-# Same Tracking-Issue marker as release-prepare — non-closing reference
-# so the originating release issue stays open through the deploy step
-# while the Kody Dashboard can still link this PR to the task for preview.
-tracking_line=""
-if [[ "$issue_arg" =~ ^[0-9]+$ && "$issue_arg" != "0" ]]; then
-  tracking_line=$'\n\nTracking-Issue: #'"${issue_arg}"
-fi
-body=$(build_pr_body "$tracking_line")
-
-# 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.
-body_max=65000
-if (( ${#body} > body_max )); then
-  echo "[kody release-deploy] PR body ${#body} chars > ${body_max} — truncating changelog" >&2
-  budget=$(( body_max - 2000 ))
-  changelog_section="${changelog_section:0:budget}"$'\n\n_…changelog truncated; see CHANGELOG.md on the branch._'
-  body=$(build_pr_body "$tracking_line")
-  (( ${#body} > body_max )) && body="${body:0:body_max}"
-fi
-
-if [[ -n "$existing" ]]; then
-  echo "  reusing existing deploy PR: ${existing}"
-  pr_url="$existing"
-  # Refresh the body so re-runs converge on the current changelog. Best-
-  # effort: a failed edit (e.g. permission-denied) shouldn't fail the
-  # release — the PR already exists and its title/branch are unchanged.
-  if ! printf '%s' "$body" | gh pr edit "$pr_url" --body-file - >/dev/null 2>&1; then
-    echo "[kody release-deploy] WARN: failed to refresh deploy PR body" >&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${version})" --body-file -); then
-    echo "KODY_REASON=release deploy: gh pr create failed"
-    echo "KODY_SKIP_AGENT=true"
-    exit 1
-  fi
-fi
-
-if [[ -z "$pr_url" ]]; then
-  echo "KODY_REASON=release deploy: empty PR URL after gh pr create"
-  echo "KODY_SKIP_AGENT=true"
-  exit 1
-fi
-
-# Persist the deploy-PR marker on the originating issue body. Mirrors the
-# release-prepare path — the issue body is owned by the orchestrator, so
-# this signal survives any @kody fix that overwrites the PR body. The
-# marker replaces the prepare-PR ref so the dashboard pivots to the deploy
-# PR (the now-current task) automatically.
-if [[ "${issue_arg:-}" =~ ^[0-9]+$ && "${issue_arg:-0}" != "0" ]]; then
-  pr_number="${pr_url##*/}"
-  if [[ "$pr_number" =~ ^[0-9]+$ ]]; then
-    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 "[kody release-deploy] WARN: failed to write kody-release-pr marker to issue #${issue_arg}"
-  fi
-fi
-
-echo "RELEASE_DEPLOY_PR=${pr_url}"
-echo "KODY_PR_URL=${pr_url}"
-
-# Optional post-deploy notification (e.g. Slack ping that a deploy PR is up).
-# Substituted placeholders in the configured command:
-#   $VERSION         — release version (e.g. 0.25.4)
-#   $DEPLOY_PR_URL   — URL of the deploy PR just opened/reused
-# The notifyCommand can use $DEPLOY_PR_URL to pull real content (e.g.
-# `gh pr view $DEPLOY_PR_URL --json body --jq .body`) instead of
-# rendering a hardcoded one-liner.
-notify_status="skipped"
-if [[ -n "$notify_cmd" ]]; then
-  cmd="${notify_cmd//\$VERSION/$version}"
-  cmd="${cmd//\$DEPLOY_PR_URL/$pr_url}"
-  echo "  notify: ${cmd}"
-  if timeout "${timeout_s}" bash -c "$cmd"; then
-    notify_status="ok"
-  else
-    notify_status="failed"
-    echo "[kody release-deploy] notifyCommand failed (non-fatal)" >&2
-  fi
-fi
-
-echo "KODY_REASON=opened deploy PR ${default_branch} → ${release_branch} (notify=${notify_status})"
-echo "KODY_SKIP_AGENT=true"

package/dist/executables/release-deploy/profile.json

@@ -1,53 +0,0 @@
-{
-  "name": "release-deploy",
-  "role": "utility",
-  "phase": "shipped",
-  "describe": "Run the configured deployCommand and notifyCommand after release-publish has tagged + published. No agent.",
-  "inputs": [
-    {
-      "name": "dry-run",
-      "flag": "--dry-run",
-      "type": "bool",
-      "required": false,
-      "describe": "Print plan without running deploy/notify commands."
-    },
-    {
-      "name": "issue",
-      "flag": "--issue",
-      "type": "int",
-      "required": false,
-      "describe": "Issue/PR number to post the terminal notice on. Auto-injected by dispatch."
-    }
-  ],
-  "claudeCode": {
-    "model": "inherit",
-    "permissionMode": "acceptEdits",
-    "maxTurns": 0,
-    "maxThinkingTokens": null,
-    "systemPromptAppend": null,
-    "tools": [],
-    "hooks": [],
-    "skills": [],
-    "commands": [],
-    "subagents": [],
-    "plugins": [],
-    "mcpServers": []
-  },
-  "cliTools": [],
-  "inputArtifacts": [],
-  "outputArtifacts": [],
-  "scripts": {
-    "preflight": [
-      { "script": "setCommentTarget", "with": { "type": "issue" } },
-      { "script": "loadTaskState" },
-      { "shell": "deploy.sh" },
-      { "script": "skipAgent" }
-    ],
-    "postflight": [
-      { "script": "recordOutcome" },
-      { "script": "saveTaskState" },
-      { "script": "notifyTerminal", "with": { "label": "release deploy" } },
-      { "script": "advanceFlow" }
-    ]
-  }
-}