@kody-ade/kody-engine 0.4.224 → 0.4.225

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

@@ -1,368 +0,0 @@
-#!/usr/bin/env bash
-#
-# release-prepare: bump version files, generate CHANGELOG.md, commit on a
-# release branch, open the release PR. Pure mechanical work — no agent.
-#
-# Inputs (env, set by the executor):
-#   KODY_ARG_BUMP             patch|minor|major (default: patch)
-#   KODY_ARG_DRY_RUN          true|false
-#   KODY_ARG_PREFER           ours|theirs (optional)
-#   KODY_ARG_ISSUE            triggering issue/PR number (optional)
-#
-# Config (env, flattened from kody.config.json):
-#   KODY_CFG_GIT_DEFAULTBRANCH         e.g. main
-#   KODY_CFG_RELEASE_VERSIONFILES      JSON array, e.g. ["package.json"]
-#
-# Stdout signals to the executor:
-#   KODY_PR_URL=<url>      — set ctx.output.prUrl (final PR URL)
-#   KODY_REASON=<text>     — set ctx.output.reason (failure or dry-run note)
-#   KODY_SKIP_AGENT=true   — bypass the agent (always; this is a no-agent flow)
-
-set -euo pipefail
-
-# ── Helpers ────────────────────────────────────────────────────────────────
-
-bump="${KODY_ARG_BUMP:-patch}"
-dry_run="${KODY_ARG_DRY_RUN:-false}"
-prefer="${KODY_ARG_PREFER:-}"
-default_branch="${KODY_CFG_GIT_DEFAULTBRANCH:-main}"
-version_files_json="${KODY_CFG_RELEASE_VERSIONFILES:-}"
-
-fail() {
-  local reason="$1"
-  echo "KODY_REASON=$reason"
-  echo "KODY_SKIP_AGENT=true"
-  exit "${2:-1}"
-}
-
-bump_version() {
-  local cur="$1" kind="$2"
-  local rest="${cur#*-}"
-  local core="${cur%%-*}"
-  if ! [[ "$core" =~ ^([0-9]+)\.([0-9]+)\.([0-9]+)$ ]]; then
-    fail "release prepare: cannot parse version '$cur' (expected x.y.z[-suffix])" 99
-  fi
-  local maj="${BASH_REMATCH[1]}" min="${BASH_REMATCH[2]}" pat="${BASH_REMATCH[3]}"
-  case "$kind" in
-    major) maj=$((maj + 1)); min=0; pat=0 ;;
-    minor) min=$((min + 1)); pat=0 ;;
-    patch|*) pat=$((pat + 1)) ;;
-  esac
-  echo "${maj}.${min}.${pat}"
-}
-
-read_pkg_version() {
-  python3 -c "import json,sys; print(json.load(open('package.json'))['version'])"
-}
-
-write_pkg_version() {
-  local file="$1" new="$2"
-  python3 - "$file" "$new" <<'PY'
-import json, sys
-path, new = sys.argv[1], sys.argv[2]
-try:
-    with open(path) as f:
-        text = f.read()
-except FileNotFoundError:
-    print("MISSING")
-    sys.exit(0)
-try:
-    data = json.loads(text)
-except Exception:
-    print("UNCHANGED")
-    sys.exit(0)
-if data.get("version") == new:
-    print("UNCHANGED")
-    sys.exit(0)
-data["version"] = new
-indent = 2
-with open(path, "w") as f:
-    f.write(json.dumps(data, indent=indent) + "\n")
-print("WROTE")
-PY
-}
-
-resolve_version_files() {
-  if [[ -z "$version_files_json" ]]; then
-    echo "package.json"
-    return
-  fi
-  python3 - <<PY
-import json, os, sys
-raw = os.environ.get("KODY_CFG_RELEASE_VERSIONFILES", "")
-try:
-    arr = json.loads(raw)
-except Exception:
-    print("package.json")
-    sys.exit(0)
-if isinstance(arr, list) and arr:
-    for f in arr:
-        if isinstance(f, str) and f:
-            print(f)
-else:
-    print("package.json")
-PY
-}
-
-generate_changelog() {
-  local new_version="$1"
-  local last_tag count
-  # actions/checkout@v4 with fetch-depth: 0 still does NOT fetch tags by
-  # default — operators have to opt in via `fetch-tags: true`. When tags
-  # are absent, `git describe` returns empty and the else-branch's
-  # 100-commit window can over- or under-shoot. Try once to backfill
-  # tags before describing, ignoring failures (offline/sandbox runs).
-  if ! last_tag=$(git describe --tags --abbrev=0 --match 'v*' 2>/dev/null); then
-    git fetch --tags --quiet 2>/dev/null || true
-    last_tag=$(git describe --tags --abbrev=0 --match 'v*' 2>/dev/null || true)
-  fi
-  if [[ -n "$last_tag" ]]; then
-    count=$(git rev-list --count "${last_tag}..HEAD" --no-merges 2>/dev/null || echo "?")
-    echo "  changelog: ${count} commits since ${last_tag}" >&2
-    git log "${last_tag}..HEAD" --pretty=format:'%s||%h' --no-merges 2>/dev/null || true
-  else
-    echo "  changelog: no previous v* tag found — using last 100 commits" >&2
-    git log -n100 HEAD --pretty=format:'%s||%h' --no-merges 2>/dev/null || true
-  fi
-}
-
-format_changelog() {
-  local new_version="$1"
-  local date_str
-  date_str=$(date -u +%Y-%m-%d)
-  python3 - "$new_version" "$date_str" <<PY
-import sys, re
-new_version, date_str = sys.argv[1], sys.argv[2]
-raw = sys.stdin.read()
-buckets = {k: [] for k in ("feat", "fix", "perf", "refactor", "docs", "chore", "other")}
-for line in raw.splitlines():
-    line = line.strip()
-    if not line:
-        continue
-    if "||" not in line:
-        continue
-    subject, sha = line.split("||", 1)
-    if re.match(r"(?i)^chore:\s*release\s+v\d", subject):
-        continue
-    m = re.match(r"^(\w+)(?:\(.*?\))?\s*:\s*(.+)$", subject)
-    if m:
-        kind = m.group(1).lower()
-        msg = m.group(2)
-    else:
-        kind = "other"
-        msg = subject
-    buckets.setdefault(kind, buckets["other"]).append(f"- {msg} ({sha})")
-labels = [
-    ("feat", "Features"),
-    ("fix", "Fixes"),
-    ("perf", "Performance"),
-    ("refactor", "Refactoring"),
-    ("docs", "Docs"),
-    ("chore", "Chores"),
-    ("other", "Other"),
-]
-parts = [f"## v{new_version} — {date_str}", ""]
-emitted = False
-for key, label in labels:
-    items = buckets.get(key) or []
-    if not items:
-        continue
-    parts.append(f"### {label}")
-    parts.extend(items)
-    parts.append("")
-    emitted = True
-if not emitted:
-    parts.append("_No notable commits since the last release._")
-    parts.append("")
-sys.stdout.write("\n".join(parts))
-PY
-}
-
-prepend_changelog() {
-  local entry="$1"
-  local header='# Changelog
-
-All notable changes to this project will be documented in this file.
-
-'
-  if [[ -f CHANGELOG.md ]]; then
-    if grep -qE '^#\s*Changelog\b' CHANGELOG.md; then
-      python3 - "$entry" <<'PY'
-import sys
-entry = sys.argv[1]
-with open("CHANGELOG.md") as f:
-    prior = f.read()
-idx = prior.index("\n", prior.index("# Changelog"))
-new = prior[: idx + 1] + "\n" + entry + prior[idx + 1 :]
-with open("CHANGELOG.md", "w") as f:
-    f.write(new)
-PY
-    else
-      python3 - "$entry" <<'PY'
-import sys
-entry = sys.argv[1]
-header = "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\n"
-with open("CHANGELOG.md") as f:
-    prior = f.read()
-with open("CHANGELOG.md", "w") as f:
-    f.write(header + entry + prior)
-PY
-    fi
-  else
-    python3 - "$entry" <<'PY'
-import sys
-entry = sys.argv[1]
-header = "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\n"
-with open("CHANGELOG.md", "w") as f:
-    f.write(header + entry)
-PY
-  fi
-}
-
-remote_branch_exists() {
-  local branch="$1"
-  git ls-remote --heads origin "$branch" 2>/dev/null | grep -q .
-}
-
-find_open_pr() {
-  local branch="$1"
-  gh pr list --head "$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 ""
-}
-
-# ── Flow ───────────────────────────────────────────────────────────────────
-
-if [[ ! -f package.json ]]; then
-  fail "release prepare: package.json not found" 99
-fi
-
-old_version=$(read_pkg_version)
-new_version=$(bump_version "$old_version" "$bump")
-tag="v${new_version}"
-release_branch="release/${tag}"
-
-echo "→ release prepare: ${old_version} → ${new_version} (${bump})"
-
-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 "KODY_SKIP_AGENT=true"
-  exit 0
-fi
-
-# Branch-collision gate.
-collides=false
-if remote_branch_exists "$release_branch"; then
-  collides=true
-  case "$prefer" in
-    theirs)
-      existing=$(find_open_pr "$release_branch")
-      if [[ -n "$existing" ]]; then
-        echo "  reusing existing PR (--prefer theirs): ${existing}"
-        echo "KODY_PR_URL=${existing}"
-        echo "KODY_REASON=reused existing release PR"
-        echo "KODY_SKIP_AGENT=true"
-        exit 0
-      fi
-      fail "release prepare --prefer theirs: ${release_branch} exists on remote but has no open PR — nothing to reuse" 4
-      ;;
-    ours)
-      echo "  branch ${release_branch} exists on remote — will force-push (--prefer ours)"
-      ;;
-    *)
-      fail "release prepare: branch ${release_branch} already exists on remote. Use --prefer ours to force-push, or --prefer theirs to reuse the existing PR." 4
-      ;;
-  esac
-fi
-
-# Bump version files.
-mapfile -t files < <(resolve_version_files)
-touched=()
-for f in "${files[@]}"; do
-  res=$(write_pkg_version "$f" "$new_version")
-  if [[ "$res" == "WROTE" ]]; then
-    touched+=("$f")
-  fi
-done
-if [[ ${#touched[@]} -eq 0 ]]; then
-  fail "release prepare: no version strings updated (files: ${files[*]})"
-fi
-echo "  wrote    ${touched[*]}"
-
-# Changelog.
-raw_log=$(generate_changelog "$new_version") || raw_log=""
-entry=$(printf '%s' "$raw_log" | format_changelog "$new_version")
-prepend_changelog "$entry"
-echo "  wrote    CHANGELOG.md"
-
-# Commit + push.
-export HUSKY=0 SKIP_HOOKS=1
-git checkout -b "$release_branch"
-for f in "${touched[@]}" CHANGELOG.md; do
-  git add -- "$f"
-done
-git -c commit.gpgsign=false commit -m "chore: release ${tag}"
-if [[ "$collides" == "true" && "$prefer" == "ours" ]]; then
-  git push -u --force-with-lease origin "$release_branch"
-else
-  git push -u origin "$release_branch"
-fi
-
-# Open PR (or link to existing one if --prefer ours collided).
-pr_url=""
-if [[ "$collides" == "true" && "$prefer" == "ours" ]]; then
-  pr_url=$(find_open_pr "$release_branch")
-fi
-
-if [[ -z "$pr_url" ]]; then
-  body_max=60000
-  if [[ ${#entry} -gt $body_max ]]; then
-    body_entry="${entry:0:$body_max}
-
-_… truncated; see CHANGELOG.md_"
-  else
-    body_entry="$entry"
-  fi
-  # Link the PR back to the originating release issue WITHOUT auto-closing
-  # it. The orchestrator continues to publish + deploy after merge using the
-  # issue as the dispatch target, so the issue must stay open for the
-  # dashboard to keep showing the task as in-progress until finishFlow
-  # applies kody:done. We use `Tracking-Issue: #N` (not `Closes #N`) — GitHub
-  # treats this as plain text, the dashboard parses it as a fallback link
-  # signal, and no auto-close fires on PR merge.
-  issue_arg="${KODY_ARG_ISSUE:-}"
-  tracking_line=""
-  if [[ "$issue_arg" =~ ^[0-9]+$ && "$issue_arg" != "0" ]]; then
-    tracking_line=$'\n\nTracking-Issue: #'"${issue_arg}"
-  fi
-  body=$'Automated release PR opened by kody.\n\n'"$body_entry"$'\n\nThe release orchestrator will merge this into `'"${default_branch}"$'` and continue to publish + deploy.'"${tracking_line}"
-  pr_url=$(printf '%s' "$body" | gh pr create --head "$release_branch" --base "$default_branch" --title "chore: release ${tag}" --body-file -)
-fi
-
-if [[ -z "$pr_url" ]]; then
-  fail "release prepare: gh pr create returned empty URL" 4
-fi
-
-# Persist a release-PR marker on the originating issue body so the Kody
-# Dashboard can link the issue → PR even if @kody fix later overwrites the
-# PR body. Idempotent: any existing marker line is stripped before append,
-# so re-runs replace the previous PR ref. The issue body is owned by the
-# orchestrator (no @kody fix touches it), so this signal is durable.
-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-prepare] WARN: failed to write kody-release-pr marker to issue #${issue_arg}"
-  fi
-fi
-
-echo "RELEASE_PR=${pr_url}"
-echo "KODY_PR_URL=${pr_url}"
-echo "KODY_REASON=opened release PR for ${tag}"
-echo "KODY_SKIP_AGENT=true"

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

@@ -1,70 +0,0 @@
-{
-  "name": "release-prepare",
-  "role": "utility",
-  "phase": "shipped",
-  "describe": "Bump version files, generate CHANGELOG.md, commit on a release branch, open the release PR. No agent.",
-  "inputs": [
-    {
-      "name": "bump",
-      "flag": "--bump",
-      "type": "enum",
-      "values": ["patch", "minor", "major"],
-      "required": false,
-      "describe": "Version bump increment. Default patch."
-    },
-    {
-      "name": "dry-run",
-      "flag": "--dry-run",
-      "type": "bool",
-      "required": false,
-      "describe": "Print plan without writing files, committing, or opening a PR."
-    },
-    {
-      "name": "prefer",
-      "flag": "--prefer",
-      "type": "enum",
-      "values": ["ours", "theirs"],
-      "required": false,
-      "describe": "On release/vX.Y.Z branch collision: 'ours' force-pushes; 'theirs' reuses the existing PR. Default refuses non-ff."
-    },
-    {
-      "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": "prepare.sh" },
-      { "script": "skipAgent" }
-    ],
-    "postflight": [
-      { "script": "recordOutcome" },
-      { "script": "saveTaskState" },
-      { "script": "mirrorStateToPr" },
-      { "script": "notifyTerminal", "with": { "label": "release prepare" } },
-      { "script": "advanceFlow" }
-    ]
-  }
-}

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

@@ -1,53 +0,0 @@
-{
-  "name": "release-publish",
-  "role": "utility",
-  "phase": "shipped",
-  "describe": "Tag the merged release commit, run the configured publishCommand, create the GitHub release. No agent.",
-  "inputs": [
-    {
-      "name": "dry-run",
-      "flag": "--dry-run",
-      "type": "bool",
-      "required": false,
-      "describe": "Print plan without tagging or publishing."
-    },
-    {
-      "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": "publish.sh" },
-      { "script": "skipAgent" }
-    ],
-    "postflight": [
-      { "script": "recordOutcome" },
-      { "script": "saveTaskState" },
-      { "script": "notifyTerminal", "with": { "label": "release publish" } },
-      { "script": "advanceFlow" }
-    ]
-  }
-}

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

@@ -1,137 +0,0 @@
-#!/usr/bin/env bash
-#
-# release-publish: tag the current package version, push the tag, run the
-# configured publishCommand (e.g. `pnpm publish --access public`), create
-# the GitHub release. Runs AFTER the orchestrator has merged the release
-# PR into the default branch. No agent.
-#
-# Inputs (env):
-#   KODY_ARG_DRY_RUN          true|false
-#   KODY_ARG_ISSUE            triggering issue/PR number (optional)
-#
-# Config (env):
-#   KODY_CFG_GIT_DEFAULTBRANCH         e.g. main
-#   KODY_CFG_RELEASE_PUBLISHCOMMAND    optional; $VERSION is substituted
-#   KODY_CFG_RELEASE_DRAFTRELEASE      "true" → create as draft
-#   KODY_CFG_RELEASE_TIMEOUTMS         publish timeout (default 600000ms)
-#
-# Stdout signals:
-#   KODY_REASON=<text>
-#   KODY_PR_URL=<release URL>   — gh release create URL (used as the "PR" link)
-#   KODY_SKIP_AGENT=true
-
-set -euo pipefail
-
-dry_run="${KODY_ARG_DRY_RUN:-false}"
-default_branch="${KODY_CFG_GIT_DEFAULTBRANCH:-main}"
-publish_cmd="${KODY_CFG_RELEASE_PUBLISHCOMMAND:-}"
-draft="${KODY_CFG_RELEASE_DRAFTRELEASE:-false}"
-timeout_ms="${KODY_CFG_RELEASE_TIMEOUTMS:-600000}"
-timeout_s=$((timeout_ms / 1000))
-
-fail() {
-  echo "KODY_REASON=$1"
-  echo "KODY_SKIP_AGENT=true"
-  exit "${2:-1}"
-}
-
-read_pkg_version() {
-  python3 -c "import json; print(json.load(open('package.json'))['version'])"
-}
-
-if [[ ! -f package.json ]]; then
-  fail "release publish: package.json not found" 99
-fi
-
-export HUSKY=0 SKIP_HOOKS=1 CI="${CI:-1}"
-
-# Make sure we're on the merged commit. The orchestrator merged the release
-# PR into default_branch; pull so the local tree has the bump commit.
-git fetch origin "$default_branch" --tags
-git checkout "$default_branch"
-git reset --hard "origin/$default_branch"
-
-version=$(read_pkg_version)
-tag="v${version}"
-
-echo "→ release publish: ${tag}"
-
-# Recovery is resume-not-overwrite: a release is three steps (push tag, run
-# publishCommand, create GH release) and any of them may already be done from
-# a prior partial run. We probe each step's state and perform only the missing
-# parts. An already-fully-released version is therefore a no-op success, and we
-# never re-point or force an existing tag (that would rewrite a shipped version).
-tag_local=false
-tag_remote=false
-release_exists=false
-if git rev-parse --verify "$tag" >/dev/null 2>&1; then tag_local=true; fi
-if git ls-remote --exit-code --tags origin "refs/tags/$tag" >/dev/null 2>&1; then tag_remote=true; fi
-if gh release view "$tag" >/dev/null 2>&1; then release_exists=true; fi
-
-if [[ "$tag_local" == "true" || "$tag_remote" == "true" || "$release_exists" == "true" ]]; then
-  echo "  resuming: tag exists (local=${tag_local} remote=${tag_remote}), gh-release=${release_exists}"
-fi
-
-if [[ "$dry_run" == "true" ]]; then
-  echo "KODY_REASON=dry-run — would tag + publish ${tag} (tag_remote=${tag_remote}, gh-release=${release_exists})"
-  echo "KODY_SKIP_AGENT=true"
-  exit 0
-fi
-
-# Tag + push (skip whichever half already exists).
-if [[ "$tag_local" == "false" && "$tag_remote" == "false" ]]; then
-  git tag -a "$tag" -m "Release ${tag}"
-fi
-if [[ "$tag_remote" == "false" ]]; then
-  git push origin "$tag"
-fi
-
-# publishCommand (optional). A version that's already on the registry is the
-# expected recovery case, not an error: treat "already published" as done.
-# Any other non-zero is a real failure (recorded, but we still create the GH
-# release so the tag is discoverable).
-publish_status="skipped"
-if [[ -n "$publish_cmd" ]]; then
-  cmd="${publish_cmd//\$VERSION/$version}"
-  echo "  publish: ${cmd}"
-  publish_out=""
-  if publish_out=$(timeout "${timeout_s}" bash -c "$cmd" 2>&1); then
-    publish_status="ok"
-  elif echo "$publish_out" | grep -qiE "already exists|cannot publish over|previously published|403 Forbidden"; then
-    publish_status="already-published"
-    echo "[kody release-publish] version ${version} already on registry — treating as published"
-  else
-    publish_status="failed"
-    echo "[kody release-publish] publishCommand failed (continuing to create GH release)" >&2
-  fi
-  echo "$publish_out"
-fi
-
-# GitHub release (create only if missing).
-release_url=""
-if [[ "$release_exists" == "true" ]]; then
-  release_url=$(gh release view "$tag" --json url --jq .url 2>/dev/null || echo "")
-else
-  draft_flag=""
-  [[ "$draft" == "true" ]] && draft_flag="--draft"
-  if release_url=$(gh release create "$tag" --title "$tag" --notes "Release ${tag} — automated by kody." $draft_flag 2>&1); then
-    :
-  else
-    echo "[kody release-publish] gh release create failed: $release_url" >&2
-    release_url=""
-  fi
-fi
-
-echo "RELEASE_TAG=${tag}"
-[[ -n "$release_url" ]] && echo "RELEASE_URL=${release_url}"
-
-if [[ "$publish_status" == "failed" ]]; then
-  echo "KODY_REASON=tag + GH release created, but publishCommand failed"
-  echo "KODY_SKIP_AGENT=true"
-  exit 1
-fi
-
-[[ -n "$release_url" ]] && echo "KODY_PR_URL=${release_url}"
-echo "KODY_REASON=tagged ${tag}, published${publish_status:+ ($publish_status)}"
-echo "KODY_SKIP_AGENT=true"
-exit 0

package/dist/executables/resolve/apply-prefer.sh

@@ -1,54 +0,0 @@
-#!/usr/bin/env bash
-#
-# Deterministic conflict resolution for `kody resolve --prefer ours|theirs`.
-#
-# Runs as a preflight shell entry (see src/executables/resolve/profile.json).
-# Gated by runWhen on args.prefer, so it only fires when the user requested
-# a side. Reads the side from $KODY_ARG_PREFER (the executor exposes every
-# ctx.args.<key> as an env var).
-#
-# Preconditions set by the prior `resolveFlow` preflight:
-#   - cwd is on the PR branch.
-#   - `git merge origin/<base> --no-edit --no-ff` already ran and conflicted.
-#   - Working tree has unmerged paths.
-#
-# Behavior: for each unmerged file, git checkout --ours (or --theirs), add,
-# commit the merge, push the branch. Prints `KODY_SKIP_AGENT=true` on
-# success so the executor bypasses the agent entirely.
-#
-# Exits:
-#   0   — resolved + pushed (or nothing to resolve)
-#   64  — invalid side value
-#   1+  — git operation failed (executor will surface stderr)
-
-set -euo pipefail
-
-side="${KODY_ARG_PREFER:-}"
-if [[ "$side" != "ours" && "$side" != "theirs" ]]; then
-  echo "apply-prefer: expected KODY_ARG_PREFER=ours|theirs, got '$side'" >&2
-  exit 64
-fi
-
-unmerged=$(git diff --name-only --diff-filter=U)
-if [[ -z "$unmerged" ]]; then
-  echo "apply-prefer: no unmerged paths — nothing to resolve"
-  echo "KODY_SKIP_AGENT=true"
-  exit 0
-fi
-
-count=0
-while IFS= read -r f; do
-  [[ -z "$f" ]] && continue
-  git checkout "--$side" -- "$f"
-  git add -- "$f"
-  count=$((count + 1))
-done <<< "$unmerged"
-echo "apply-prefer: resolved $count file(s) via --$side"
-
-# Complete the merge. git merge left MERGE_MSG in place; --no-edit uses it.
-HUSKY=0 SKIP_HOOKS=1 git -c commit.gpgsign=false commit --no-edit
-
-branch=$(git rev-parse --abbrev-ref HEAD)
-git push origin "$branch"
-echo "apply-prefer: pushed $branch"
-echo "KODY_SKIP_AGENT=true"