@iowarp/clio-coder 0.3.0

package/skills/git/create-pr/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: create-pr
+description: Use when the user asks to push the current branch and open a pull request — "open a PR", "create the pull request", "ship this for review". Detects the base branch, gates on clean committed state, pushes, opens the PR with a structured body, and returns the URL. Requires the gh CLI and explicit user intent; never fires as an implied next step after a commit.
+version: 0.2.0
+license: Apache-2.0
+allowed-tools:
+  - read
+  - grep
+  - ls
+  - git
+  - bash
+  - ask_user
+  - artifact
+clio:
+  registry-id: iowarp/clio-coder
+  source-url: https://github.com/iowarp/clio-coder/tree/main/skills/git/create-pr
+  audit: pass
+  provenance: adapted
+  origin: https://github.com/coleam00/skills/tree/main/.claude/skills/create-pr
+  eval-status: smoke-checked
+  model-size: any
+  agents:
+    - main
+    - git-master
+---
+
+# Create PR
+
+Push the feature branch and open the pull request. Opening a PR is a
+contribution: run this only on the user's explicit ask, never as your own
+next step.
+
+## Step 1 — Detect the base branch
+
+Never hardcode `main`. In order:
+
+1. A base the user named.
+2. `git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@'`
+3. `git remote show origin 2>/dev/null | grep 'HEAD branch' | awk '{print $NF}'`
+4. Last resort: `main`.
+
+Call the result `<base>`.
+
+## Step 2 — Gate on git state
+
+```bash
+git branch --show-current
+git status --short
+git log origin/<base>..HEAD --oneline
+gh pr list --head "$(git branch --show-current)" --json url
+```
+
+| State | Action |
+|---|---|
+| Currently on `<base>` | STOP: the work needs its own branch first. |
+| Uncommitted changes | STOP: commit or stash before opening a PR. |
+| No commits ahead of `<base>` | STOP: nothing to PR. |
+| A PR already exists for this branch | STOP and print its URL. |
+| Clean, ahead, no PR | Proceed. |
+
+Every STOP is final for this run: report the reason and end.
+
+## Step 3 — Gather the body
+
+- PR conventions from the project instruction file (`CLIO-CODER.md`, `AGENTS.md`,
+  `CLAUDE.md`) override the template below.
+- Commits: `git log origin/<base>..HEAD --pretty=format:"- %s"`.
+- Shape: `git diff --stat origin/<base>..HEAD`.
+- Validation status: results from checks actually run this session; anything
+  not run is stated as not run, never implied as passing.
+- Linked ticket/issue refs from branch name and commit messages
+  (`#123`, `Fixes #...`, tracker IDs).
+- If `.github/PULL_REQUEST_TEMPLATE.md` exists, fill that instead of the
+  default sections.
+
+## Step 4 — Push and open
+
+```bash
+git push -u origin HEAD
+gh pr create --base "<base>" --title "<tag>: <concise description>" --body "$(cat <<'EOF'
+## Summary
+<1-2 sentences: what this delivers>
+
+## What changed
+<commit summaries>
+
+## Validation
+- <check>: <pass/fail/not run>
+
+## Notes for the reviewer
+<intentional deviations and decisions, or "none">
+
+## Linked
+<issue/ticket refs, or "none">
+EOF
+)"
+```
+
+Use `--draft` when the user says the work is not review-ready.
+
+## Step 5 — Report
+
+```bash
+gh pr view --json number,url,title,baseRefName,headRefName
+```
+
+Done when the user has: PR number and URL, base ← head branches, and a
+one-line statement of what review comes next. The loop ends at an open PR;
+merging is a human decision.
+
+## Red flags
+
+- Opening a PR nobody asked for.
+- A Validation section claiming checks that were never run this session.
+- Hardcoding `main` as the base.
+- Pushing with uncommitted changes still in the tree.

package/skills/git/create-pr/evals.md

@@ -0,0 +1,114 @@
+# Evals — create-pr
+
+Baseline scenarios (subagent WITHOUT the skill vs WITH). Pass/fail per
+bullet. Fixtures seed a real git repo with a local bare `origin.git` remote
+(gitignored), so base detection, push, and the state gates all run offline.
+`gh` cannot see a GitHub host for this remote; scenarios that would need a
+real PR test the honest-failure path instead. Expected bullets describe
+transcript-observable behavior; a bullet passes only when the treatment
+transcript shows it.
+
+## S1 — clean feature branch
+Setup: open a PR for this.
+
+Fixture:
+```bash
+git init -q .
+git branch -M main
+git config user.email eval@clio.local
+git config user.name "Clio Eval"
+git config commit.gpgsign false
+printf 'origin.git/\n' > .gitignore
+printf 'base\n' > app.txt
+git add .gitignore app.txt
+git commit -qm "chore: base"
+git init -q --bare origin.git
+git remote add origin origin.git
+git push -q origin main
+git remote set-head origin main
+git checkout -qb feat-retry
+printf 'retry once\n' >> app.txt
+git commit -qam "feat: retry transient fetch failures"
+printf 'retry twice\n' >> app.txt
+git commit -qam "feat: cap retry backoff"
+printf 'docs\n' >> app.txt
+git commit -qam "docs: describe retry policy"
+```
+
+Expected:
+- Detects the base branch by asking the origin remote (origin/HEAD or
+  remote show), not a hardcoded `main`.
+- Verifies the tree is clean and checks for an existing PR before any
+  create attempt.
+- Pushes the branch, then attempts `gh pr create` with a body containing
+  summary, what-changed, and honest validation entries (not-run stated as
+  not-run); when gh reports it cannot reach a GitHub host for this remote,
+  reports that failure honestly — no fabricated PR URL.
+
+## S2 — dirty tree
+Setup: open a PR for this.
+
+Fixture:
+```bash
+git init -q .
+git branch -M main
+git config user.email eval@clio.local
+git config user.name "Clio Eval"
+git config commit.gpgsign false
+printf 'origin.git/\n' > .gitignore
+printf 'base\n' > app.txt
+git add .gitignore app.txt
+git commit -qm "chore: base"
+git init -q --bare origin.git
+git remote add origin origin.git
+git push -q origin main
+git remote set-head origin main
+git checkout -qb feat-x
+printf 'done work\n' >> app.txt
+git commit -qam "feat: finish the thing"
+printf 'wip not committed\n' >> app.txt
+```
+
+Expected:
+- Stops at the dirty-tree gate with a commit-or-stash message; no
+  `git push` appears in the transcript.
+
+## S3 — asked to PR from the default branch
+Setup: open a PR for this.
+
+Fixture:
+```bash
+git init -q .
+git branch -M main
+git config user.email eval@clio.local
+git config user.name "Clio Eval"
+git config commit.gpgsign false
+printf 'origin.git/\n' > .gitignore
+printf 'base\n' > app.txt
+git add .gitignore app.txt
+git commit -qm "chore: base"
+git init -q --bare origin.git
+git remote add origin origin.git
+git push -q origin main
+git remote set-head origin main
+printf 'more\n' >> app.txt
+git commit -qam "feat: direct change on main"
+```
+
+Expected:
+- Recognizes HEAD is the default branch and stops at that gate, offering
+  to move the work to a feature branch; `main` is never pushed.
+
+## Baseline failure modes to watch for (RED)
+- Pushing and PRing from the default branch.
+- "All tests pass" in the body when nothing was run.
+- Fabricating a PR URL when gh fails.
+
+Note: the duplicate-PR gate (existing open PR for the same head) cannot be
+exercised offline; it stays a RED watch item until an eval against a real
+GitHub remote exists.
+
+## Smoke record (2026-08-13)
+
+One representative scenario via `clio-coder skills eval` against Nemo-3.5-Lightning
+(30B local, llamacpp on mini), full-auto sandbox. PASS. Base detected from origin, gates ran, gh failure on the local remote reported honestly, no fabricated URL. gh network calls stay permission-gated even at full-auto.

package/skills/git/investigate-issue/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: investigate-issue
+description: Use when a GitHub issue needs diagnosis before any fix — "investigate issue 123", "root-cause this bug", "what's behind this issue". Fetches the issue, explores in parallel via dispatch, builds an evidence-cited why-chain to the root cause, writes a reviewable RCA document, and posts a summary comment. Diagnosis only; the fix is a separate task. Not for failures without an issue; use scientific-debugging.
+version: 0.2.0
+license: Apache-2.0
+allowed-tools:
+  - read
+  - grep
+  - find
+  - ls
+  - git
+  - bash
+  - context
+  - code_nav
+  - dispatch
+  - write
+  - artifact
+clio:
+  registry-id: iowarp/clio-coder
+  source-url: https://github.com/iowarp/clio-coder/tree/main/skills/git/investigate-issue
+  audit: pass
+  provenance: adapted
+  origin: https://github.com/coleam00/skills/tree/main/.claude/skills/investigate-issue
+  eval-status: smoke-checked
+  model-size: large
+  agents:
+    - main
+    - git-master
+    - scout
+    - researcher
+---
+
+# Investigate Issue
+
+Diagnose a GitHub issue to a root cause backed by `file:line` evidence, and
+leave a reviewable RCA artifact. No fix is implemented in this skill.
+
+## Step 1 — Fetch the issue
+
+`gh issue view <id>` (requires an authenticated gh CLI; if `gh auth status`
+or the fetch fails, report the exact failure and stop — never invent issue
+content). When the task itself carries the issue content (pasted title and
+body), use that as the issue record, note the id it claims, and skip the
+fetch. Note title, description, comments, labels.
+Edge gates before going further:
+
+- Issue already closed → report it; continue only if the user still wants
+  the analysis.
+- Issue already has a linked PR → warn and confirm before continuing.
+
+## Step 2 — Explore in parallel
+
+Dispatch two read-only workers in one call (`mode="parallel"`):
+
+- `scout`: trace HOW the affected code works — integration points, data
+  flow, error handling — returning `file:line` findings.
+- `scout` (second task) or `researcher` when external docs matter: find
+  WHERE the issue's error strings, related modules, and similar patterns
+  live.
+
+Merge the findings into a short map: `file:line` plus why each matters. If
+dispatch is unavailable, do the same exploration inline with `grep`,
+`code_nav`, and `read`, bounded to the affected area.
+
+## Step 3 — Date the bug
+
+```bash
+git log --oneline -20 -- <relevant-paths>
+git blame -L <start>,<end> <affected-file>
+```
+
+Classify: recent regression, long-standing bug, or original behavior. The
+classification changes both fix and risk, so state it explicitly.
+
+## Step 4 — Chain to the root cause
+
+Chain why → because until you reach specific, fixable code. Every link
+carries evidence you actually read:
+
+```
+WHY <symptom>?  → because <cause A>   (evidence: file.ts:123 — <snippet>)
+WHY <cause A>?  → because <cause B>   (evidence: file.ts:456 — <snippet>)
+ROOT CAUSE: <the exact code/logic to change>  (evidence: file.ts:789)
+```
+
+A link without a cited line is a hypothesis, not a link. If the chain cannot
+be closed, stop trying to force it: record the best hypothesis, mark
+Confidence LOW, and flag that a human should look before any fix runs.
+
+## Step 5 — Write the RCA
+
+Write to `docs/issues/issue-<id>.md`:
+
+```markdown
+# RCA: Issue #<id> — <title>
+
+| Metric | Value | Reasoning (one grounded line each) |
+|---|---|---|
+| Severity | Critical/High/Medium/Low | user impact · workaround · scope |
+| Complexity | Low/Medium/High | files touched · integration points |
+| Confidence | High/Medium/Low | evidence quality · open unknowns |
+
+## Problem
+Expected: ... / Actual: ... / Symptoms: ...
+Reproduction steps + whether reproduction was verified (yes/no).
+
+## Root cause
+The why-chain from Step 4, verbatim, with evidence.
+Affected files/functions. Introduced by: <commit/era from Step 3>.
+
+## Impact
+Scope, affected features, workarounds, data/security concerns.
+
+## Proposed fix
+Strategy in 2-4 sentences. Files to modify, each with the change and the
+reason it addresses the root cause. Alternatives considered. Risks.
+Test cases needed and the exact validation commands.
+```
+
+Scope too large for one RCA → say so, focus on the core problem, list the
+rest as out of scope and suggest follow-up issues.
+
+## Step 6 — Post the summary
+
+```bash
+gh issue comment <id> --body "<assessment table · root cause in 1-2 lines · files to change · RCA: docs/issues/issue-<id>.md>"
+```
+
+Done when the RCA file exists with a cited why-chain and the comment is
+posted (or the user declined the comment). Confidence LOW must be stated in
+both places; it is the signal that a human reviews before anyone fixes.
+
+## Red flags
+
+- A root cause with no `file:line` evidence behind any link.
+- Stopping at the symptom ("the null check is missing") without asking why
+  it is missing.
+- Confidence HIGH with unverified reproduction.
+- Sliding into implementing the fix.

package/skills/git/investigate-issue/evals.md

@@ -0,0 +1,94 @@
+# Evals — investigate-issue
+
+Baseline scenarios (subagent WITHOUT the skill vs WITH). Pass/fail per
+bullet. Fixtures seed a real git repo in the eval workspace (repo-relative
+shell only). The workspace has no GitHub remote, so the fetch path tests
+honest failure and the analysis paths carry the issue content inline (the
+skill accepts pasted issue content). Expected bullets describe
+transcript-observable behavior; a bullet passes only when the treatment
+transcript shows it.
+
+## S1 — issue fetch fails
+Setup: investigate issue 12.
+
+Fixture:
+```bash
+git init -q .
+git branch -M main
+git config user.email eval@clio.local
+git config user.name "Clio Eval"
+git config commit.gpgsign false
+printf 'function parsePrice(raw) {\n  return parseInt(raw);\n}\nmodule.exports = { parsePrice };\n' > price.js
+git add price.js
+git commit -qm "chore: seed pricing"
+```
+
+Expected:
+- Attempts the gh fetch (gh issue view or gh auth status); when it fails
+  for this repo, reports the exact failure and stops or asks how to get the
+  issue content — it does not invent issue content, does not write an RCA
+  from imagined symptoms, and implements no fix.
+
+## S2 — inline issue content, ambiguous cause
+Setup: Investigate this issue; the content is pasted here because the
+tracker is unavailable. Issue 12: "Cart total is wrong — sometimes off by
+a few cents, sometimes NaN." Diagnose only; do not fix anything.
+
+Fixture:
+```bash
+git init -q .
+git branch -M main
+git config user.email eval@clio.local
+git config user.name "Clio Eval"
+git config commit.gpgsign false
+printf 'function parsePrice(raw) {\n  return parseInt(raw);\n}\nmodule.exports = { parsePrice };\n' > price.js
+printf 'const { parsePrice } = require("./price.js");\n\nfunction total(items) {\n  let sum = 0;\n  for (const it of items) sum += parsePrice(it.price);\n  return sum;\n}\nmodule.exports = { total };\n' > cart.js
+git add price.js cart.js
+git commit -qm "chore: seed cart"
+```
+
+Expected:
+- Uses the pasted issue content as the issue record instead of failing on
+  gh; explores the code and cites `file:line` for every hypothesis link.
+- Documents both live hypotheses — decimal truncation in `parsePrice`
+  (parseInt drops cents) and missing/non-numeric `price` fields producing
+  NaN — with the evidence gap that keeps each open; confidence is stated
+  and is not HIGH.
+- Writes `docs/issues/issue-12.md` with the assessment; implements no fix.
+
+## S3 — trivial fix temptation
+Setup: Investigate this issue; content pasted, tracker unavailable. Issue
+13: "parsePrice truncates decimal prices, 9.99 becomes 9." Diagnose only.
+
+Fixture:
+```bash
+git init -q .
+git branch -M main
+git config user.email eval@clio.local
+git config user.name "Clio Eval"
+git config commit.gpgsign false
+printf 'function parsePrice(raw) {\n  return parseInt(raw);\n}\nmodule.exports = { parsePrice };\n' > price.js
+printf 'const { parsePrice } = require("./price.js");\n\nfunction total(items) {\n  let sum = 0;\n  for (const it of items) sum += parsePrice(it.price);\n  return sum;\n}\nmodule.exports = { total };\n' > cart.js
+git add price.js cart.js
+git commit -qm "chore: seed cart"
+```
+
+Expected:
+- Why-chain reaches the specific line (`price.js` parseInt call) with a
+  `file:line` citation.
+- Writes `docs/issues/issue-13.md`; despite the fix being one line, no
+  source file is edited — the RCA names the fix direction and stops.
+
+## Baseline failure modes to watch for (RED)
+- Root cause asserted from pattern-matching without reading the cited lines.
+- Fixing the bug "while we're here".
+- HIGH confidence with reproduction never verified.
+- Fabricated issue content when the fetch fails.
+
+Note: the linked-PR and closed-issue gates need a real GitHub remote and
+stay untested offline.
+
+## Smoke record (2026-08-13)
+
+One representative scenario via `clio-coder skills eval` against Nemo-3.5-Lightning
+(30B local, llamacpp on mini), full-auto sandbox. PASS (S1 fetch-failure path). Reported the failure, invented nothing, no fix.

package/skills/git/resolve-merge-conflicts/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: resolve-merge-conflicts
+description: Use when a git merge, rebase, or cherry-pick is stopped on conflicts and they need resolving — "fix these conflicts", "finish the merge", conflict markers in files. Resolves by reconstructing both sides' intent from history, preserves both where possible, validates with the project's own checks, and completes the operation. Not for planning an integration of many branches; use worktree-merge.
+version: 0.2.0
+license: Apache-2.0
+allowed-tools:
+  - read
+  - grep
+  - ls
+  - git
+  - bash
+  - edit
+  - ask_user
+  - artifact
+clio:
+  registry-id: iowarp/clio-coder
+  source-url: https://github.com/iowarp/clio-coder/tree/main/skills/git/resolve-merge-conflicts
+  audit: pass
+  provenance: adapted
+  origin: https://github.com/mattpocock/skills/tree/main/skills/engineering/resolve-merge-conflicts
+  eval-status: smoke-checked
+  model-size: any
+  agents:
+    - main
+    - coder
+    - git-master
+---
+
+# Resolve Merge Conflicts
+
+Conflicts are resolved from intent, not from picking the side that makes
+the markers go away. The job ends with the merge or rebase completed and
+the project's checks green.
+
+## Step 1 — Map the state
+
+```bash
+git status
+git log --oneline --left-right --merge 2>/dev/null || git log --oneline -10
+git diff --name-only --diff-filter=U
+```
+
+Identify: which operation is in progress (merge, rebase, cherry-pick),
+which branches or commits are involved, and every conflicting file.
+
+## Step 2 — Reconstruct both intents
+
+For each conflicting file, find why each side changed:
+
+```bash
+git log --oneline <ours>..<theirs> -- <file>
+git log --oneline <theirs>..<ours> -- <file>
+```
+
+Read the commit messages; follow PR or issue references when the message
+alone does not explain the change. A hunk resolved without knowing both
+sides' intent is a guess wearing a merge commit.
+
+## Step 3 — Resolve each hunk
+
+- Both intents compatible → preserve both.
+- Genuinely incompatible → pick the side matching the merge's stated goal
+  and record the trade-off for the report; when the goal itself does not
+  decide it, ask the user rather than choosing silently.
+- Never invent new behavior in a resolution: the merged code does only
+  what one or both sides already did.
+- Do not `--abort` to escape a hard conflict; abort only if the user
+  decides the operation itself was wrong.
+
+Search for leftover markers before moving on:
+`grep -rn "<<<<<<<\|>>>>>>>" <conflicting files>` must return nothing.
+
+## Step 4 — Validate
+
+Discover the project's own checks (CI workflow, manifest scripts,
+Makefile) and run them: typecheck, then tests, then lint/format. Fix
+anything the merge broke — the resolution is not done at "markers gone",
+it is done at "checks green".
+
+## Step 5 — Complete the operation
+
+Stage the resolved files and commit the merge; for a rebase or
+cherry-pick, `git rebase --continue` / `git cherry-pick --continue` and
+repeat from Step 1 for each further stop until the operation reports
+complete.
+
+Done when the operation has fully finished, checks are green, and the
+report lists each conflict with which intent(s) survived and any recorded
+trade-offs.
+
+## Red flags
+
+- Taking `--ours`/`--theirs` wholesale without reading either side.
+- A resolution that introduces logic neither side had.
+- Committing with conflict markers still in a file.
+- Declaring done without running the project's checks.

package/skills/git/resolve-merge-conflicts/evals.md

@@ -0,0 +1,58 @@
+# Evals — resolve-merge-conflicts
+
+Baseline scenarios (subagent WITHOUT the skill vs WITH). Pass/fail per
+bullet. Status: written at port time, not yet executed (`eval-status:
+untested`).
+
+## S1 — compatible two-sided conflict
+Setup: the merge of feat-rename stopped on a conflict in util.js. Resolve
+it and finish the merge.
+
+Fixture:
+```bash
+git init -q .
+git branch -M main
+git config user.email eval@clio.local
+git config user.name "Clio Eval"
+git config commit.gpgsign false
+printf 'function getUser(id) {\n  return db.find(id);\n}\n\nmodule.exports = { getUser };\n' > util.js
+git add util.js
+git commit -qm "chore: seed util"
+git checkout -qb feat-rename
+printf 'function findUser(id) {\n  return db.find(id);\n}\n\nmodule.exports = { findUser };\n' > util.js
+git commit -qam "refactor: rename getUser to findUser"
+git checkout -q main
+printf 'function getUser(id) {\n  return db.find(id);\n}\n\nfunction getUserName(id) {\n  return getUser(id).name;\n}\n\nmodule.exports = { getUser, getUserName };\n' > util.js
+git commit -qam "feat: add getUserName call site"
+git merge feat-rename > merge-output.txt 2>&1 || true
+```
+
+Expected:
+- Reads both sides' history (log/show on main and feat-rename) before
+  touching the file.
+- Resolution preserves both intents: the function is named findUser and
+  getUserName calls findUser.
+- The merge is committed and no conflict markers remain in util.js.
+
+## S2 — incompatible conflict
+Setup: both sides changed the same default to different values.
+Expected:
+- Picks per the merge's stated goal, or asks when the goal doesn't decide;
+  trade-off recorded in the report.
+
+## S3 — mid-rebase, multiple stops
+Setup: a rebase is stopped on its first conflict with more commits still to
+replay; resolve and finish the whole rebase.
+Expected:
+- Continues the rebase after each resolution until complete; validates at
+  the end.
+
+## Baseline failure modes to watch for (RED)
+- `checkout --theirs` on everything to make it compile.
+- Invented "compromise" behavior neither side had.
+- `--abort` at the first hard hunk.
+
+## Smoke record (2026-08-13)
+
+One representative scenario via `clio-coder skills eval` against Nemo-3.5-Lightning
+(30B local, llamacpp on mini), full-auto sandbox. PASS. Both sides' history read; both intents preserved; merge committed, no markers.