@weotro/dx 0.1.4 → 0.1.6

package/skills/oo-ship-issue-pr/references/runtime.md

@@ -0,0 +1,92 @@
+# Codex Runtime Contract
+
+仅在共享流程进入外部专家或 follow-up 分支时读取。
+
+## Claude 专家通道
+
+### 可用性探测与会话级熔断
+
+第一次需要外部专家时运行 `command -v claude` 和 `claude --version`，分别保留退出码、stdout 和 stderr。该探测不是交付硬门禁：任一命令非零、不可执行或超时，都把 Claude 通道标记为“本次不可用”，立即由 fresh Codex subagent 接管当前阶段；不得退出、输出阻塞或停止共享流程。
+
+“本次不可用”状态持续到当前顶层 `oo-ship-issue-pr` 调用结束，覆盖后续方案讨论、实现、review、修复和回收阶段。状态一旦设置，后续不再探测或调用 Claude，每个需要外部专家的阶段都直接创建 fresh Codex subagent；subagent 也不可用时由 Codex 主进程降级接管。新的顶层 `oo-ship-issue-pr` 调用才重新探测 Claude。
+
+探测通过后，所有调用从当前 worktree 根目录执行，固定使用 `--effort medium --no-session-persistence`。首选模型是 Claude Fable 5（`--model fable`）；仅在该次调用明确因 Fable 额度不足失败时，以完全相同的 prompt、权限模式和工具集合重试一次 Claude Opus 5（`--model opus`）。Claude 只写工作树；Git 历史、GitHub、权威验证和最终事实核验由 Codex 主进程负责。
+
+### 模型额度回退
+
+Claude 通道未被标记为“本次不可用”时，每次外部专家调用都重新从 Fable 开始，不因上一轮曾回退而直接选择 Opus。保留每次尝试的退出码、stdout 和 stderr，并按以下顺序处理：
+
+1. Fable 返回 0：接受结果，不调用 Opus。
+2. Fable 非零，且输出明确表示当前模型的使用额度、配额或 credits 已耗尽（例如 `hit your limit`、`usage limit`、`quota exceeded`、`credit balance is too low`、`insufficient credits` 或带重置时间的额度提示）：只重试一次 Opus。
+3. Fable 的失败属于未登录、认证、网络、超时、无效模型、参数、权限、工具或其他非额度错误：保留原错误，不调用 Opus，把 Claude 通道标记为“本次不可用”，立即进入 fresh subagent 回退。
+4. Opus 返回 0：接受 Opus 结果，并在阶段报告中记录本轮实际模型为 `Claude Opus 5`。
+5. Opus 失败：记录 Fable 与 Opus 两次证据，把 Claude 通道标记为“本次不可用”，停止 Claude 重试并立即进入 fresh subagent 回退。不得继续循环或换用其他 Claude 模型。
+
+下面命令块中的 `fable` 是首选尝试。命令非零时同时检查 stdout 与 stderr；只有命中上述额度回退条件，才将 `--model fable` 替换为 `--model opus` 原样重跑一次。重试前清空或更换 `RESULT_FILE`，避免把 Fable 的部分输出混入 Opus 结果。
+
+### 只读讨论、review 与 adversarial review
+
+把 Issue、验收标准、base、方案或已确认问题写入本次任务唯一的 `PROMPT_FILE`：
+
+```bash
+claude -p \
+  --model fable \
+  --effort medium \
+  --permission-mode plan \
+  --tools "Read,Grep,Glob,Bash" \
+  --no-session-persistence \
+  < "$PROMPT_FILE" > "$RESULT_FILE"
+```
+
+prompt 要求只读、不修改文件、不执行 Git/GitHub 写操作、不递归委派，并直接读取源码和 `git diff <base>...HEAD` 取证。
+
+- 普通 review 以 findings 为主，按严重级排序；每项包含严重级、`文件:行号`、证据、影响和具体修法。
+- adversarial review 先挑战方案假设、构造反例和失败路径，再输出同样格式的 findings；没有证据的问题不进入报告。
+
+### 重改动实现与修复
+
+```bash
+claude -p \
+  --model fable \
+  --effort medium \
+  --permission-mode acceptEdits \
+  --tools "Read,Grep,Glob,Edit,Write,Bash" \
+  --no-session-persistence \
+  < "$PROMPT_FILE" > "$RESULT_FILE"
+```
+
+prompt 必须包含 Issue、逐条验收标准、最终方案、涉及目录和 `AGENTS.md` 路由，并要求只改验收范围、不 commit、不 push、不碰 GitHub、不递归委派、保护已有未提交改动，最后报告修改路径和未运行验证。
+
+## Claude 不可用时的 fresh subagent
+
+可用性探测失败、当前调用在模型额度回退后仍无有效结果，或因安装、登录、认证、网络、超时、参数、权限、工具等原因无法使用 Claude 时，主进程立即调用 Codex `spawn_agent` 创建一个全新的 `worker` subagent 接管当前外部专家阶段。Claude 通道同时进入“本次不可用”状态，后续外部专家阶段直接走本节，不再尝试 Claude。每次回退都新建 agent，不复用此前 agent；使用 `fork_turns: "none"`，在 prompt 中完整提供任务上下文。
+
+fallback prompt 必须包含：
+
+- 当前 worktree 的绝对路径，以及只在该 worktree 工作。
+- 当前阶段是只读方案讨论、只读 review、adversarial review、实现还是修复；只承接这一阶段，不运行完整 `oo-ship-issue-pr`。
+- Issue 原文、逐条验收标准、base、主进程初步方案或最终方案，以及该阶段所需的 diff、已确认问题和验证上下文。
+- 先读取根与涉及目录的 `AGENTS.md`；它不是代码库中唯一执行者，保护已有未提交改动，不回退其他人的修改。
+- 只读阶段保持工作树不变；实现或修复阶段的所有权限定为 prompt 列出的验收范围和涉及文件，改动留在工作树。
+- 不 commit、不 push、不操作 GitHub、不调用 Claude、不递归委派；最后返回证据、结论、修改路径和未运行验证。
+
+主进程等待 fresh subagent 返回后按外部专家的同一标准逐条复核，再继续共享流程。`spawn_agent` 本身不可用或派发失败时，主进程直接完成同一阶段并记录 `Codex 主进程降级`；Claude 通道不可用和 subagent 派发失败都不得单独中断交付链。
+
+## 结果、等待与补跑
+
+Claude CLI 是前台同步调用。命令返回、成功模型的 `RESULT_FILE` 可完整读取且工作树稳定即算返回；非零退出按模型额度回退和会话级熔断规则处理，卡住时记录命令与原因，把 Claude 通道标记为“本次不可用”，然后进入 fresh subagent 回退。
+
+Claude 通道不可用时由 fresh subagent 继续当前阶段；subagent 也不可用时由 Codex 主进程直接接管。Claude 或 subagent 执行过的验证只作参考，阶段五及后续轮次要求的全部权威验证由 Codex 主进程重新执行并阅读最新输出。
+
+Claude 或 fresh subagent 返回后，Codex 主进程逐条直读源码复核，合并重复项并记录拒绝依据。
+
+## 阶段与报告映射
+
+- 阶段四方案讨论：只读外部专家，记录实际使用的 Fable 5、Opus 5、fresh Codex subagent 或 Codex 主进程降级。
+- 阶段四实现与阶段 7.4 重修复：可写外部专家，记录实际使用的 Fable 5、Opus 5、fresh Codex subagent 或 Codex 主进程降级。
+- 阶段 7.3：复杂度门禁命中且本 PR 尚未用过外部专家审查时执行 review；需要挑战方案时执行 adversarial review。成功返回的 fresh Codex subagent 计入本 PR 唯一一次外部专家审查，Codex 主进程降级不计入。
+- reviewer：`Codex 主进程自审 / Claude Fable 5 review / Claude Fable 5 adversarial review / Claude Opus 5 review / Claude Opus 5 adversarial review / fresh Codex subagent review / fresh Codex subagent adversarial review / Codex 主进程降级 review / Codex 主进程降级 adversarial review`，按本轮实际执行者填写。
+
+## Follow-up
+
+使用 Codex `spawn_agent` 的 `worker` 角色，prompt 指定 worktree 绝对路径并要求调用 `oo-ship-issue-pr`。明确告知 worker 它不是代码库中唯一执行者，不回退其他人的改动，只在指定 worktree 工作。派发深度只允许一层；worker 发现的新 follow-up 只建 Issue。

package/skills/prune-git-repository/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: prune-git-repository
+description: 仅在用户显式调用 $prune-git-repository、/prune-git-repository 或明确要求使用 prune-git-repository 技能时使用；不要通过关键词、任务类型或上下文自动触发。
+---
+
+# Prune Git Repository
+
+Use the bundled scripts instead of rebuilding shell loops. Always run them from the target repository.
+
+## Authorization gate
+
+Treat every execute mode as destructive.
+
+1. Require explicit current-turn authorization for the exact cleanup categories and thresholds.
+2. Run dry-run mode first and report counts, cutoff, keep sets, protected refs, and occupied branches.
+3. Pass `--execute` only after the authorization covers the previewed deletions.
+4. Never delete the base branch, remote default branch, current worktree, or current branch.
+5. Preserve unrelated working-tree changes. Do not infer permission to push recent local-only branches.
+
+Read [pitfalls.md](references/pitfalls.md) before any execute run.
+
+## Workflow
+
+When multiple categories are authorized, use this order:
+
+1. Inspect `git status`, remotes, default branch, `gh auth status`, and worktrees.
+2. Preview all selected scripts.
+3. Remove extra worktrees first so checked-out candidate branches can be deleted.
+4. Prune branches.
+5. Prune Releases and tags.
+6. Fetch/prune and run the scripts again without `--execute`; require zero remaining candidates.
+7. Verify `main...origin/main`, a clean current worktree, server-side refs through `ls-remote`, and matching local/remote tag sets.
+
+## Commands
+
+Resolve the installed script directory once:
+
+```bash
+PRUNE_SKILL_ROOT="${AGENTS_HOME:-$HOME/.agents}/skills/prune-git-repository"
+```
+
+Preview branch cleanup:
+
+```bash
+"$PRUNE_SKILL_ROOT/scripts/prune-branches.sh" \
+  --remote origin --base main --stale-days 20
+```
+
+Execute the authorized branch cleanup:
+
+```bash
+"$PRUNE_SKILL_ROOT/scripts/prune-branches.sh" \
+  --remote origin --base main --stale-days 20 --execute
+```
+
+Preview or remove all linked worktrees except the current worktree:
+
+```bash
+"$PRUNE_SKILL_ROOT/scripts/prune-worktrees.sh"
+"$PRUNE_SKILL_ROOT/scripts/prune-worktrees.sh" --execute
+```
+
+Preview or retain only the newest tags and GitHub Releases:
+
+```bash
+"$PRUNE_SKILL_ROOT/scripts/prune-tags-releases.sh" \
+  --remote origin --keep 10
+"$PRUNE_SKILL_ROOT/scripts/prune-tags-releases.sh" \
+  --remote origin --keep 10 --execute
+```
+
+Use `--tags-only` only when the user explicitly excludes GitHub Releases. The combined mode requires the retained tag names and retained Release tag names to match; stop for user direction if they differ.
+
+## Reporting
+
+Report:
+
+- effective cutoff and keep set;
+- deleted local/remote branch counts by reason;
+- deleted local/remote tag and GitHub Release counts;
+- removed and pruned worktree counts;
+- any protected, occupied, failed, or deliberately retained items;
+- final local/server counts, set diffs, `main` ahead/behind, and worktree status.

package/skills/prune-git-repository/agents/openai.yaml

@@ -0,0 +1,6 @@
+interface:
+  display_name: "清理 Git 仓库"
+  short_description: "安全清理旧分支、标签、Release 与 worktree"
+  default_prompt: "Use $prune-git-repository to preview and safely clean stale Git branches, old tags and Releases, and extra worktrees."
+policy:
+  allow_implicit_invocation: false

package/skills/prune-git-repository/references/pitfalls.md

@@ -0,0 +1,43 @@
+# Failure modes and guardrails
+
+Read this file before execute mode.
+
+## Raw output and `rtk`
+
+- Use `rtk proxy git ...` for machine-readable Git output. Plain `rtk git worktree list --porcelain` may render human-friendly paths and remove `worktree ` prefixes.
+- Use `rtk proxy gh ...` and `rtk proxy jq ...` when complete JSON or line lists are required. Plain `rtk` can replace the middle of a long list with a truncation marker; never feed rendered output back into deletion commands.
+- Verify remote deletion with `rtk proxy git ls-remote`, not only local remote-tracking refs.
+- `rtk rm -rf` may be protected/no-op. Remove registered worktrees with Git first. Use the narrowly scoped `find ... -exec /bin/rm -rf` fallback only after Git removal fails and the path is proven to be a non-current registered worktree.
+
+## Shell hazards
+
+- Use Bash arrays for batches. Do not rely on scalar word splitting; zsh does not split scalar variables by default and can turn a whole batch into one invalid refspec.
+- Never use `path` as a zsh loop variable; it is tied to `PATH` and can make `git`, `sed`, and `rtk` disappear mid-script. Use `wt_path`.
+- Under `set -e`, avoid standalone arithmetic tests or `((count++))`; a zero result exits with status 1. Put arithmetic comparisons inside `if` and use `count=$((count + 1))`.
+- Use exact refspecs (`:refs/heads/...`, `:refs/tags/...`) to avoid branch/tag ambiguity.
+
+## Branch classification
+
+- Fetch with `--prune` before classifying.
+- Determine merge state with `git merge-base --is-ancestor <tip> <remote/base>`; branch names and PR state are not topology evidence.
+- Classify local and remote tips independently. A recent local branch can track an already-deleted or stale remote ref; do not publish it unless the user explicitly authorizes pushing it.
+- Exclude the exact remote HEAD symref and base ref. `origin/HEAD` may render as `origin`, so filtering only the short name `HEAD` is unsafe.
+- Protect branches checked out by any worktree. Remove authorized extra worktrees first or report the branch as occupied.
+- Calculate the cutoff portably: macOS `date -v-<N>d`, GNU `date -d '<N> days ago'`.
+
+## Tags and Releases
+
+- Use `git ls-remote --tags --refs`; without `--refs`, annotated tags add `^{}` pseudo-refs and corrupt counts.
+- Fetch tags before sorting by `creatordate`. Compare local-only and remote-only tags explicitly.
+- When tags and GitHub Releases are cleaned together, require the newest tag set and newest Release tag-name set to match before execution. Otherwise stopping is safer than leaving retained Releases without their tags.
+- Retrieve all Releases with `gh release list --limit 1000 --json ...` through `rtk proxy`; re-query after deletion.
+- Delete old Releases before their old tags, then synchronize and compare the retained tag sets.
+
+## Worktrees
+
+- Read paths only from raw `git worktree list --porcelain` output.
+- Canonicalize the current repository root and compare exact absolute paths. Never compare against a display path containing `~`.
+- Use `git worktree remove --force --force` and wait for it to finish; dependency directories can make deletion slow.
+- Run `git worktree prune --expire now` for missing or partially removed worktrees.
+- If Git says a registered directory is not a working tree, delete only that already-validated registered directory, then prune. Never broaden the fallback to a parent directory shared with the current checkout.
+- After cleanup, raw porcelain output must contain exactly the current worktree.

package/skills/prune-git-repository/scripts/prune-branches.sh

@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+remote=origin
+base=main
+stale_days=20
+execute=false
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --remote) remote=$2; shift 2 ;;
+    --base) base=$2; shift 2 ;;
+    --stale-days) stale_days=$2; shift 2 ;;
+    --execute) execute=true; shift ;;
+    *) echo "unknown argument: $1" >&2; exit 2 ;;
+  esac
+done
+
+[[ "$stale_days" =~ ^[0-9]+$ ]] || { echo "--stale-days must be a non-negative integer" >&2; exit 2; }
+command -v rtk >/dev/null || { echo "rtk is required" >&2; exit 1; }
+git_raw() { rtk proxy git "$@"; }
+
+git_raw rev-parse --is-inside-work-tree >/dev/null
+git_raw fetch "$remote" --prune
+base_ref="refs/remotes/$remote/$base"
+git_raw show-ref --verify --quiet "$base_ref" || { echo "missing $base_ref" >&2; exit 1; }
+
+if cutoff=$(date -v-"${stale_days}"d +%s 2>/dev/null); then
+  cutoff_iso=$(date -r "$cutoff" '+%Y-%m-%d %H:%M:%S %z')
+else
+  cutoff=$(date -d "$stale_days days ago" +%s)
+  cutoff_iso=$(date -d "@$cutoff" '+%Y-%m-%d %H:%M:%S %z')
+fi
+
+tmp=$(mktemp -d)
+trap 'rm -rf "$tmp"' EXIT
+: > "$tmp/local"
+: > "$tmp/remote"
+: > "$tmp/protected"
+current=$(git_raw branch --show-current)
+git_raw worktree list --porcelain | sed -n 's/^branch refs\/heads\///p' > "$tmp/checked-out"
+
+git_raw for-each-ref --format='%(refname)|%(refname:short)|%(committerdate:unix)' refs/heads > "$tmp/local-refs"
+while IFS='|' read -r ref short ts; do
+  [[ "$short" == "$base" ]] && continue
+  reason=
+  if git_raw merge-base --is-ancestor "$ref" "$base_ref"; then
+    reason=merged
+  elif [[ "$ts" -le "$cutoff" ]]; then
+    reason=stale-unmerged
+  fi
+  if [[ -n "$reason" ]] && grep -Fqx "$short" "$tmp/checked-out"; then
+    printf 'local|%s|%s\n' "$short" "$reason" >> "$tmp/protected"
+  elif [[ -n "$reason" ]]; then
+    printf '%s|%s|%s\n' "$short" "$reason" "$ts" >> "$tmp/local"
+  fi
+done < "$tmp/local-refs"
+
+git_raw for-each-ref --format='%(refname)|%(committerdate:unix)' "refs/remotes/$remote" > "$tmp/remote-refs"
+while IFS='|' read -r ref ts; do
+  [[ "$ref" == "refs/remotes/$remote/HEAD" || "$ref" == "$base_ref" ]] && continue
+  name=${ref#"refs/remotes/$remote/"}
+  [[ "$name" == "$ref" || -z "$name" ]] && continue
+  reason=
+  if git_raw merge-base --is-ancestor "$ref" "$base_ref"; then
+    reason=merged
+  elif [[ "$ts" -le "$cutoff" ]]; then
+    reason=stale-unmerged
+  fi
+  if [[ -n "$reason" ]] && grep -Fqx "$name" "$tmp/checked-out"; then
+    printf 'remote|%s|%s\n' "$name" "$reason" >> "$tmp/protected"
+  elif [[ -n "$reason" ]]; then
+    printf '%s|%s|%s\n' "$name" "$reason" "$ts" >> "$tmp/remote"
+  fi
+done < "$tmp/remote-refs"
+
+echo "cutoff=$cutoff_iso"
+echo "local_candidates=$(wc -l < "$tmp/local" | tr -d ' ')"
+awk -F'|' '{print "  " $1 " [" $2 "]"}' "$tmp/local"
+echo "remote_candidates=$(wc -l < "$tmp/remote" | tr -d ' ')"
+awk -F'|' '{print "  " $1 " [" $2 "]"}' "$tmp/remote"
+echo "protected_checked_out=$(wc -l < "$tmp/protected" | tr -d ' ')"
+awk -F'|' '{print "  " $1 ":" $2 " [" $3 "]"}' "$tmp/protected"
+
+if ! $execute; then
+  echo "dry_run=true"
+  exit 0
+fi
+
+failures=0
+
+batch=()
+flush_remote_batch() {
+  [[ ${#batch[@]} -eq 0 ]] && return 0
+  if ! git_raw push "$remote" "${batch[@]}"; then
+    failures=$((failures + 1))
+  fi
+  batch=()
+}
+
+while IFS='|' read -r name reason ts; do
+  [[ -z "$name" ]] && continue
+  batch+=(":refs/heads/$name")
+  if [[ ${#batch[@]} -ge 30 ]]; then flush_remote_batch; fi
+done < "$tmp/remote"
+flush_remote_batch
+
+local_deleted=0
+while IFS='|' read -r name reason ts; do
+  [[ -z "$name" ]] && continue
+  if git_raw branch -D -- "$name"; then
+    local_deleted=$((local_deleted + 1))
+  else
+    failures=$((failures + 1))
+  fi
+done < "$tmp/local"
+
+git_raw fetch "$remote" --prune
+remote_left=0
+while IFS='|' read -r name reason ts; do
+  [[ -z "$name" ]] && continue
+  if git_raw ls-remote --exit-code --heads "$remote" "refs/heads/$name" >/dev/null 2>&1; then
+    remote_left=$((remote_left + 1))
+  fi
+done < "$tmp/remote"
+
+local_left=0
+while IFS='|' read -r name reason ts; do
+  [[ -z "$name" ]] && continue
+  if git_raw show-ref --verify --quiet "refs/heads/$name"; then
+    local_left=$((local_left + 1))
+  fi
+done < "$tmp/local"
+
+echo "local_deleted=$local_deleted local_left=$local_left remote_left=$remote_left failures=$failures"
+[[ "$local_left" -eq 0 && "$remote_left" -eq 0 && "$failures" -eq 0 ]]

package/skills/prune-git-repository/scripts/prune-tags-releases.sh

@@ -0,0 +1,117 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+remote=origin
+keep=10
+execute=false
+tags_only=false
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --remote) remote=$2; shift 2 ;;
+    --keep) keep=$2; shift 2 ;;
+    --execute) execute=true; shift ;;
+    --tags-only) tags_only=true; shift ;;
+    *) echo "unknown argument: $1" >&2; exit 2 ;;
+  esac
+done
+
+[[ "$keep" =~ ^[1-9][0-9]*$ ]] || { echo "--keep must be a positive integer" >&2; exit 2; }
+command -v rtk >/dev/null || { echo "rtk is required" >&2; exit 1; }
+git_raw() { rtk proxy git "$@"; }
+gh_raw() { rtk proxy gh "$@"; }
+jq_raw() { rtk proxy jq "$@"; }
+
+git_raw rev-parse --is-inside-work-tree >/dev/null
+git_raw fetch "$remote" --tags --prune
+tmp=$(mktemp -d)
+trap 'rm -rf "$tmp"' EXIT
+
+git_raw for-each-ref --sort=-creatordate --format='%(refname:short)' refs/tags | sed -n "1,${keep}p" > "$tmp/keep-tags"
+sort "$tmp/keep-tags" > "$tmp/keep-tags-sorted"
+git_raw tag --list | sort > "$tmp/local-tags"
+git_raw ls-remote --tags --refs "$remote" | awk '{sub("refs/tags/", "", $2); print $2}' | sort > "$tmp/remote-tags"
+comm -23 "$tmp/local-tags" "$tmp/keep-tags-sorted" > "$tmp/delete-local"
+comm -23 "$tmp/remote-tags" "$tmp/keep-tags-sorted" > "$tmp/delete-remote"
+
+echo "keep_tags=$(wc -l < "$tmp/keep-tags" | tr -d ' ')"
+sed 's/^/  /' "$tmp/keep-tags"
+echo "delete_local_tags=$(wc -l < "$tmp/delete-local" | tr -d ' ')"
+echo "delete_remote_tags=$(wc -l < "$tmp/delete-remote" | tr -d ' ')"
+
+if ! $tags_only; then
+  command -v gh >/dev/null || { echo "gh is required for Release cleanup" >&2; exit 1; }
+  command -v jq >/dev/null || { echo "jq is required for Release cleanup" >&2; exit 1; }
+  gh_raw auth status >/dev/null
+  gh_raw release list --limit 1000 --json tagName,publishedAt,createdAt,isDraft,isPrerelease,name > "$tmp/releases.json"
+  jq_raw -r 'sort_by(.publishedAt // .createdAt) | reverse | .[].tagName' "$tmp/releases.json" | sed -n "1,${keep}p" > "$tmp/keep-releases"
+  jq_raw -r 'sort_by(.publishedAt // .createdAt) | reverse | .[].tagName' "$tmp/releases.json" | sed -n "$((keep + 1)),\$p" > "$tmp/delete-releases"
+  sort "$tmp/keep-releases" > "$tmp/keep-releases-sorted"
+  echo "keep_releases=$(wc -l < "$tmp/keep-releases" | tr -d ' ')"
+  sed 's/^/  /' "$tmp/keep-releases"
+  echo "delete_releases=$(wc -l < "$tmp/delete-releases" | tr -d ' ')"
+  if ! cmp -s "$tmp/keep-tags-sorted" "$tmp/keep-releases-sorted"; then
+    echo "retained tag and Release sets differ; refusing combined cleanup" >&2
+    diff -u "$tmp/keep-tags-sorted" "$tmp/keep-releases-sorted" || true
+    exit 1
+  fi
+fi
+
+if ! $execute; then
+  echo "dry_run=true"
+  exit 0
+fi
+
+if ! $tags_only; then
+  while IFS= read -r tag_name; do
+    [[ -z "$tag_name" ]] && continue
+    gh_raw release delete "$tag_name" --yes
+  done < "$tmp/delete-releases"
+fi
+
+batch=()
+flush_tag_batch() {
+  [[ ${#batch[@]} -eq 0 ]] && return 0
+  git_raw push "$remote" "${batch[@]}"
+  batch=()
+}
+while IFS= read -r tag_name; do
+  [[ -z "$tag_name" ]] && continue
+  batch+=(":refs/tags/$tag_name")
+  if [[ ${#batch[@]} -ge 40 ]]; then flush_tag_batch; fi
+done < "$tmp/delete-remote"
+flush_tag_batch
+
+batch=()
+while IFS= read -r tag_name; do
+  [[ -z "$tag_name" ]] && continue
+  batch+=("$tag_name")
+  if [[ ${#batch[@]} -ge 80 ]]; then
+    git_raw tag -d "${batch[@]}"
+    batch=()
+  fi
+done < "$tmp/delete-local"
+[[ ${#batch[@]} -eq 0 ]] || git_raw tag -d "${batch[@]}"
+
+# Synchronize retained local-only tags after old remote tags are removed.
+while IFS= read -r tag_name; do
+  [[ -z "$tag_name" ]] && continue
+  if ! git_raw ls-remote --exit-code --tags --refs "$remote" "refs/tags/$tag_name" >/dev/null 2>&1; then
+    git_raw push "$remote" "refs/tags/$tag_name:refs/tags/$tag_name"
+  fi
+done < "$tmp/keep-tags"
+
+git_raw fetch "$remote" --prune --prune-tags
+git_raw tag --list | sort > "$tmp/final-local"
+git_raw ls-remote --tags --refs "$remote" | awk '{sub("refs/tags/", "", $2); print $2}' | sort > "$tmp/final-remote"
+cmp -s "$tmp/final-local" "$tmp/final-remote" || { diff -u "$tmp/final-local" "$tmp/final-remote"; exit 1; }
+[[ $(wc -l < "$tmp/final-local" | tr -d ' ') -eq $(wc -l < "$tmp/keep-tags" | tr -d ' ') ]]
+
+if ! $tags_only; then
+  gh_raw release list --limit 1000 --json tagName,publishedAt,createdAt > "$tmp/final-releases.json"
+  jq_raw -r '.[].tagName' "$tmp/final-releases.json" | sort > "$tmp/final-release-tags"
+  cmp -s "$tmp/final-remote" "$tmp/final-release-tags" || { diff -u "$tmp/final-remote" "$tmp/final-release-tags"; exit 1; }
+fi
+
+echo "final_tag_count=$(wc -l < "$tmp/final-local" | tr -d ' ')"
+if ! $tags_only; then echo "final_release_count=$(jq_raw 'length' "$tmp/final-releases.json")"; fi

package/skills/prune-git-repository/scripts/prune-worktrees.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+execute=false
+if [[ "${1:-}" == "--execute" ]]; then
+  execute=true
+elif [[ $# -ne 0 ]]; then
+  echo "usage: $0 [--execute]" >&2
+  exit 2
+fi
+
+command -v rtk >/dev/null || { echo "rtk is required" >&2; exit 1; }
+git_raw() { rtk proxy git "$@"; }
+
+repo_root=$(git_raw rev-parse --show-toplevel)
+repo_root=$(cd "$repo_root" && pwd -P)
+tmp=$(mktemp -d)
+trap 'rm -rf "$tmp"' EXIT
+
+git_raw worktree list --porcelain > "$tmp/worktrees"
+sed -n 's/^worktree //p' "$tmp/worktrees" | while IFS= read -r wt_path; do
+  [[ "$wt_path" == "$repo_root" ]] && continue
+  printf '%s\n' "$wt_path"
+done > "$tmp/candidates"
+
+count=$(wc -l < "$tmp/candidates" | tr -d ' ')
+echo "current_worktree=$repo_root"
+echo "candidate_worktrees=$count"
+sed 's/^/  /' "$tmp/candidates"
+
+if ! $execute; then
+  echo "dry_run=true"
+  exit 0
+fi
+
+removed=0
+failed=0
+while IFS= read -r wt_path; do
+  [[ -z "$wt_path" ]] && continue
+  [[ "$wt_path" == "$repo_root" || "$wt_path" == "/" ]] && { echo "refusing unsafe path: $wt_path" >&2; exit 1; }
+
+  if [[ ! -e "$wt_path" ]]; then
+    continue
+  fi
+
+  if git_raw worktree remove --force --force -- "$wt_path"; then
+    removed=$((removed + 1))
+    continue
+  fi
+
+  echo "git removal failed; using registered-path fallback: $wt_path" >&2
+  if rtk proxy /usr/bin/find "$wt_path" -mindepth 1 -maxdepth 1 -exec /bin/rm -rf -- '{}' + \
+    && rtk proxy /usr/bin/find "$wt_path" -depth -delete >/dev/null 2>&1; then
+    removed=$((removed + 1))
+  else
+    failed=$((failed + 1))
+  fi
+done < "$tmp/candidates"
+
+git_raw worktree prune --expire now
+git_raw worktree list --porcelain > "$tmp/final"
+sed -n 's/^worktree //p' "$tmp/final" | awk -v current="$repo_root" '$0 != current' > "$tmp/remaining"
+remaining=$(wc -l < "$tmp/remaining" | tr -d ' ')
+
+echo "removed=$removed failed=$failed remaining=$remaining"
+if [[ "$remaining" -ne 0 || "$failed" -ne 0 ]]; then
+  sed 's/^/  remaining: /' "$tmp/remaining" >&2
+  exit 1
+fi
+
+cat "$tmp/final"

package/skills/create-issue/SKILL.md

@@ -1,90 +0,0 @@
----
-name: create-issue
-description: 仅在用户显式调用 $create-issue、/create-issue 或明确要求使用 create-issue 技能时使用；不要通过关键词、任务类型或上下文自动触发。
----
-
-# Create Issue
-
-## Overview
-
-Turn a converged discussion into issue(s) that read like **an architect handing a spec to a programmer**: the programmer can locate the work, understand the plan without asking back, and verify done objectively — without the user re-issuing instructions each time.
-
-**Core principle — write it as a task dispatch, not a bug note.** Every issue must let a programmer execute end-to-end on first read. That means three things per finding:
-1. **Stable location** — anchor to a durable identifier (`file` + function/class/symbol/section name, or a short quoted snippet). Line numbers are a *navigation hint only*, always approximate, never the anchor — code shifts and a hard line pin rots immediately and over-constrains the fix.
-2. **An unambiguous plan** — what to change and why, with no decision left dangling that forces the programmer to come back and ask.
-3. **An objective acceptance check** — verifiable by behavior/text/data-state plus a runnable command where applicable.
-
-An issue that says "the button is wrong" forces the developer to re-investigate what you already know. An issue pinned to `Button.tsx:42` sends them to the wrong line after one edit. Anchor by symbol, plan the work, define done.
-
-**Manual-only:** this skill NEVER auto-triggers on keywords (提issue / file an issue / etc.). Run it only when the user explicitly invokes `/create-issue` or names the skill.
-
-## When to Use
-
-Only on explicit invocation. Appropriate when a review/investigation has converged — you've already located code and compared against a source of truth, and actionable items emerged.
-
-**Not for:** still-exploring discussions, trivial one-line fixes the user is about to do themselves, or vague ideas with no verifiable outcome.
-
-## Workflow
-
-1. **Probe the repo's issue conventions first.** Read `CONTRIBUTING`, issue templates (`.github/`), or any `git-workflow`/ruler docs; skim a recent `gh issue list`. Match their template, labels, title style. Never hardcode another repo's format.
-2. **Group issues:**
-   - **3+ issues → always auto-create one parent/umbrella tracking issue + child issues. Do NOT ask, do NOT discuss.** Children link back with `Refs: #<parent>`; the parent lists children as a checklist and holds the cross-issue map.
-   - **Fewer than 3 → apply the Merge vs. Split table.** Confirm via AskUserQuestion only when genuinely ambiguous; otherwise state the default and proceed.
-3. **Anchor every finding to a stable location.** Anchor by `file` + durable identifier (function/class/method/symbol name, or a short quoted snippet), NOT by a hard line number. A line number may ride along as an approximate hint (`Button.tsx · onSubmit() (~L42)`), but the symbol is the anchor — it survives edits, a line pin doesn't. Pair each with its source-of-truth location (design section, spec criterion). Present as a table: `维度 | 期望(真源) | 现状(代码) | 位置(符号/锚点)`.
-4. **Plan the work like an architect.** State the intended approach so a programmer can execute without coming back to ask. Resolve the decisions you can already resolve; for genuinely open ones, say so explicitly and give the constraint/tradeoff rather than leaving a silent gap. Name the shared root cause once. Avoid ambiguity: if a phrasing could be read two ways, rewrite it.
-5. **Draw the boundary.** Explicitly list what's OUT of scope, what stays unchanged, and any knock-on effects on other files/modules — so the developer doesn't "fix" intentional things or miss a ripple. Call out adjacent code the change must NOT break.
-6. **Make acceptance criteria objective.** Each checkbox judges ONE thing, verifiable by behavior/text/data-state PLUS a runnable command (lint/build/test) where applicable. No "code is cleaner" subjective items.
-7. **Create via heredoc**, not `-m`/`--body` single-line (literal `\n` won't become newlines). Title in Conventional Commits style. For plain ordinals use `A1`/`第1项`/`` `#1` `` — never bare `#1`/`#2` (GitHub resolves them to issue links).
-8. **Review created issues — both plan AND code (MANDATORY).** After ALL issues are created, dispatch a subagent to audit them (see section below). The audit has TWO jobs: (a) verify claims match the codebase, and (b) read each issue as the programmer who'll execute it and flag any plan-level defect — ambiguity, missing decision, wrong/risky approach, undefined scope. Fix EVERY problem it reports via `gh issue edit` before reporting done.
-9. **Report back** the created URL(s) + one-line grouping/boundary summary + what the review found and fixed.
-
-## Post-Creation Review (mandatory)
-
-After creating every issue, dispatch a subagent (Explore or general-purpose). Hand it the issue numbers/URLs and have it run BOTH passes below per issue. Reading code consistency alone is not enough — a factually-correct issue can still be unexecutable.
-
-**Pass A — Code consistency (does it match reality?):**
-- Every location anchor (file + symbol) actually exists and points at the claimed code. (Don't fail an issue over a stale line-number hint — anchors are symbols; line numbers are approximate by design.)
-- Each acceptance criterion is objectively verifiable (a real command / path / behavior), not aspirational.
-- Claims about current state (bugs, missing permissions/config, signatures) are true in the code TODAY.
-- No finding contradicts the codebase or describes work already done.
-
-**Pass B — Plan soundness (read it as the assigned programmer):** Ask "could I execute this start-to-finish without coming back to ask a question?"
-- **Ambiguity:** any sentence open to two readings; vague pronouns; "fix the handling" with no defined target behavior.
-- **Missing decision:** the issue defers a choice it should have made (which API, which file, which pattern) and leaves the programmer guessing.
-- **Wrong/risky approach:** the proposed plan would break adjacent code, fight an existing convention (check ruler/CLAUDE.md), or pick a clearly worse path.
-- **Undefined scope/boundary:** no out-of-scope statement, or knock-on effects on other modules not called out.
-- **Acceptance ≠ goal:** the checkboxes, even if objective, don't actually prove the stated goal is met.
-- **Structural:** `Refs:`/parent links correct; no bare `#n` ordinal mis-links; 3+ issues have an umbrella.
-
-The subagent returns a per-issue defect list spanning both passes. **You MUST fix ALL reported problems** via `gh issue edit` (heredoc), then re-verify. Do not report the task complete while any reported problem stands unfixed.
-
-## Merge vs. Split (only when <3 issues)
-
-| Signal | Action |
-|--------|--------|
-| Same component / source-of-truth target / change cycle, mutually non-blocking | One issue, internal groups (A/B/C) |
-| Different host (e.g. web vs. mobile/Flutter), independent tracking/rollback, one item far heavier | Split, link with `Refs:` |
-| User explicitly asks to split/merge | Follow user, link related ones |
-
-## Common Mistakes
-
-- **Pinning to a hard line number** → after one edit the anchor points at the wrong code and over-constrains the fix. Anchor by file + symbol; line numbers are an approximate hint only.
-- **Filename with no symbol anchor at all** → developer re-hunts. Always name the function/class/section.
-- **Writing a bug note, not a task spec** → "X is wrong" with no plan leaves the programmer to redesign. State the intended approach.
-- **Leaving a decision dangling** → "handle this better" forces a round-trip question. Resolve it, or state the constraint explicitly if genuinely open.
-- **Acceptance criteria all subjective/visual** → not verifiable. Attach a command or observable behavior.
-- **Acceptance that doesn't prove the goal** → objective but checks the wrong thing. Tie each checkbox to the stated goal.
-- **Asking about grouping for 3+ issues** → don't. Auto-create umbrella + children.
-- **Post-creation review only checks code, not the plan** → ships factually-correct but unexecutable/ambiguous issues. Run BOTH passes (code consistency + plan soundness).
-- **No out-of-scope section** → developer changes intentional things or misses a ripple. Always state the boundary and knock-on effects.
-- **`-m "...\n..."`** → literal `\n` in the issue body. Use heredoc `--body-file -`.
-- **Bare `#1`/`#2` for ordinals** → GitHub mis-links them. Use `A1` / backticks.
-
-## Red Flags — stop and fix before reporting done
-
-- About to anchor a finding to a bare line number, or with no symbol/source-of-truth reference at all.
-- The issue describes what's wrong but not what to do about it — a programmer would have to design the fix from scratch.
-- A sentence in the issue could be read two ways, or defers a decision the issue should have made.
-- An acceptance checkbox you can't verify by running something or observing a concrete state — or that doesn't actually prove the goal.
-- 3+ issues created without an umbrella, or related issues without `Refs:`.
-- Reported done without running BOTH review passes (code + plan) and fixing every finding.