@olegkoval/agent-skills 1.28.0 → 1.29.0

package/packages/software-development/morning-routine/adapters/grok/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "olko:morning-routine",
+  "version": "0.1.0",
+  "description": "Run the complete start-of-day setup in one pass: roll over unfinished Obsidian tasks to today's daily note, sync open GitHub PRs that need your attention, and sweep Dependabot patch bumps. Chains obsidian-task-rollover, obsidian-pr-sync, and dependabot-triage.",
+  "skills": "skills/"
+}

package/packages/software-development/morning-routine/adapters/grok/skills/morning-routine/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: morning-routine
+description: >
+  Run the complete start-of-day setup in one pass: roll over unfinished Obsidian tasks
+  to today's daily note, sync open GitHub PRs that need your attention, and sweep
+  Dependabot/Renovate PRs to clear safe patch bumps. Use when the user says "start my
+  day", "morning routine", "set up my day", or when a scheduled morning job fires.
+license: MIT
+allowed-tools: Bash, Read, Write, Edit
+compatibility: Codex, Claude Code, Cursor, GitHub Copilot, Windsurf, Kiro, and other Agent Skills compatible tools. Requires git and gh (GitHub CLI) authenticated, plus a daily-note vault path configured.
+metadata:
+  targets: [_source-only]
+  author: Oleg Koval
+  tags:
+    - morning
+    - obsidian
+    - daily-note
+    - github
+    - dependabot
+    - productivity
+    - routine
+    - automation
+source: weekly-pattern-learner
+source_reason: "obsidian-task-rollover, obsidian-pr-sync, and dependabot-triage all describe themselves as morning-routine steps but no meta-skill chains them into a single first-thing-of-day pass"
+source_date: "2026-08-10"
+---
+<!-- Generated by scripts/build-adapters.sh. Do not edit directly. -->
+
+> 🤖 *Auto-generated by **weekly-pattern-learner** · obsidian-task-rollover, obsidian-pr-sync, and dependabot-triage all describe themselves as morning-routine steps but no meta-skill chains them into a single first-thing-of-day pass*
+
+# Morning Routine
+
+Run the three start-of-day workflows in sequence, then summarize what needs your
+attention today. Each phase is idempotent — re-running is safe.
+
+## Inputs
+
+- **VAULT_DAILY** (required): absolute path to the Obsidian daily notes folder
+- **GH_USERNAME** (required): GitHub login for PR filtering
+- **ORG_PREFIX** (optional): org name to group as "Work" in the PR section
+- **--skip-rollover** (optional): skip task rollover (e.g. Monday after a break)
+- **--skip-pr-sync** (optional): skip GitHub PR sync
+- **--skip-dependabot** (optional): skip Dependabot triage
+
+If any required config is missing, ask once before starting — don't abort midway.
+
+## Phase 1 — Task rollover
+
+Initialize the daily note path once, before any optional phase:
+
+```bash
+NOTE="${VAULT_DAILY}/$(date +%Y-%m-%d).md"
+```
+
+Run `olko:obsidian-task-rollover` on the **previous workday's** note.
+
+`obsidian-task-rollover` is an end-of-day migration skill — it copies unchecked tasks
+from a given day's note into the next workday's note with a `[>]` marker. When invoked
+here in the morning, it should operate on **yesterday's** (or the last workday's) note
+so those unchecked tasks are pulled forward into today's note. If yesterday's note does
+not exist, skip this step and note it in the report.
+
+**Skip if** `--skip-rollover` is set, or if it's Monday and the user has explicitly
+said they clear the board on Fridays.
+
+After this phase, confirm:
+```bash
+grep -c "^\- \[ \]" "$NOTE" 2>/dev/null || echo "0"  # open tasks today
+grep -c "^\- \[>\]" "$NOTE" 2>/dev/null || echo "0"  # migrated tasks
+```
+
+Record counts for the final report.
+
+## Phase 2 — PR sync
+
+Run `olko:obsidian-pr-sync`.
+
+This fetches all open GitHub PRs where the user is assignee or review-requested,
+filters out bots and drafts, and writes or replaces the `## PRs to review` section
+in today's daily note. PRs are grouped into Work (ORG_PREFIX org) and Personal.
+
+**Skip if** `--skip-pr-sync` is set.
+
+After this phase, count PRs written:
+```bash
+grep -c "^\- \[ \] \[" "$NOTE" 2>/dev/null || echo "0"
+```
+
+## Phase 3 — Dependabot triage (quick sweep)
+
+Run `olko:dependabot-triage` with `patch-only` auto-merge policy.
+
+This auto-approves and merges safe patch bumps whose CI is green, flags major
+upgrades for human review, and posts a digest. The `patch-only` policy means no
+minor or major bumps are merged automatically — just the safest dependency noise.
+
+**Skip if** `--skip-dependabot` is set, or if there are no open dependency PRs:
+
+```bash
+gh pr list --state open \
+  --json author --jq '
+    [.[] | select(.author.login | test("dependabot|renovate"; "i"))]
+    | length
+  ' 2>/dev/null
+```
+
+If the count is 0, skip phase 3 and note it in the report.
+
+## Final report
+
+Print a compact brief suitable for the start of the day:
+
+```
+Morning routine complete — YYYY-MM-DD
+
+  Tasks:        N open today (M carried over from yesterday)
+  PRs:          X work PRs, Y personal PRs → see ## PRs to review in today's note
+  Dependabot:   Z merged (patch, CI green), W flagged for review
+
+  Today's top 3:
+    [read from ## Top 3 for today section if populated, else print "(not filled in yet)"]
+
+  Flagged for you:
+    - [PRs older than 7 days ⚠️ from the PR sync, if any]
+    - [Major Dependabot bumps flagged for human decision, if any]
+```
+
+If a phase failed (auth expired, vault not found, network error), surface the error
+clearly rather than silently skipping that phase.
+
+## Invocation patterns
+
+**Manual (user-triggered):**
+User says "start my day", "run morning routine", or "set up today's note".
+Run the full flow and show the final report.
+
+**Scheduled (cron / CCR):**
+No user prompt needed. Run all three phases silently and emit the report as the
+run's output. Useful as a pre-meeting brief or as a first message in a new session.
+
+**Partial run:**
+If the user wants to re-sync only PRs mid-day: `--skip-rollover --skip-dependabot`.
+
+## Chaining
+
+| Before this skill | After this skill |
+|---|---|
+| — (start of session) | Work the PR queue (`olko:pr-to-green` on flagged items) |
+| — | `olko:dependabot-triage` with `patch-and-minor` if the quick sweep flagged many |
+| `olko:obsidian-task-rollover` alone | nothing — this skill already calls it |

package/packages/software-development/pr-finalize-complete/adapters/claude/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "olko-pr-finalize-complete",
-  "description": "Confirms a PR is genuinely merge-ready when the work is already believed done: re-checks every review-bot and human finding against the current code, separates stale comments from fixed ones, runs the repo's real lint and test gates, and reports the evidence rather than the assumption.",
+  "description": "Comprehensive PR finalization workflow for PRs that may already be partially addressed: checks each review comment's actual current status in code, distinguishes fixed vs. stale vs. still-present findings, verifies test coverage, runs real lint/test gates, and reports what still needs a human.",
   "skills": "./skills"
 }

package/packages/software-development/pr-finalize-complete/adapters/codex/README.md

@@ -7,18 +7,14 @@ The canonical skill definition is in `../../SKILL.md`.
 
 Invoke in a Codex session:
 
-```
-Use the olko:pr-finalize-complete skill to verify this PR is actually merge-ready.
+```text
+Use the olko:pr-finalize-complete skill to verify this PR is genuinely merge-ready.
 ```
 
 ## Workflow
 
-See `../../SKILL.md` for the full workflow: re-check every review-bot and human finding against
-the code as it stands now, separating comments that are genuinely fixed from those that are merely
-stale (bot comments on moved or renamed files are common), run the repo's real lint and test gates
-and report actual exit codes, then prepare a clean push. The procedure is plain `git`/`gh` and is
-agent-agnostic.
-
-Use this rather than `pr-finalize` when the work is believed already done and you need that claim
-verified. The skill's non-negotiables are the point: never claim a test passed without running it,
-and never resolve a bot comment without checking whether the issue still exists.
+See `../../SKILL.md` for the full workflow: establish ground truth on PR state, rebase
+only if needed, triage each review comment to determine if it's already fixed, stale,
+still present, or a false positive, verify unit test coverage for changed files, run
+the real lint/format/test gates, push if needed, and report what still needs a human.
+The procedure is plain git/gh and is agent-agnostic.

package/packages/software-development/pr-finalize-complete/adapters/cursor/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "olko:pr-finalize-complete",
   "version": "0.1.0",
-  "description": "Confirms a PR is genuinely merge-ready when the work is already believed done: re-checks every review-bot and human finding against the current code, separates stale comments from fixed ones, runs the repo's real lint and test gates, and reports the evidence rather than the assumption.",
+  "description": "Comprehensive PR finalization workflow for PRs that may already be partially addressed: checks each review comment's actual current status in code, distinguishes fixed vs. stale vs. still-present findings, verifies test coverage, runs real lint/test gates, and reports what still needs a human.",
   "skills": "skills/"
 }

package/packages/software-development/pr-finalize-complete/adapters/grok/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "olko:pr-finalize-complete",
   "version": "0.1.0",
-  "description": "Confirms a PR is genuinely merge-ready when the work is already believed done: re-checks every review-bot and human finding against the current code, separates stale comments from fixed ones, runs the repo's real lint and test gates, and reports the evidence rather than the assumption.",
+  "description": "Comprehensive PR finalization workflow for PRs that may already be partially addressed: checks each review comment's actual current status in code, distinguishes fixed vs. stale vs. still-present findings, verifies test coverage, runs real lint/test gates, and reports what still needs a human.",
   "skills": "skills/"
 }

package/packages/software-development/release-day/SKILL.md

@@ -0,0 +1,286 @@
+---
+name: release-day
+description: >
+  Orchestrate a full release-day workflow for iOS, Android, or Garmin apps: verify the
+  main branch CI is green, generate a changelog from git history, draft platform-ready
+  store listing copy, trigger semantic-release (or tag manually), wait for the build,
+  and queue the App Store submission. Use when the user says "cut a release", "ship
+  version X", "it's release day", or "prepare the release".
+license: MIT
+allowed-tools: Bash, Read, Write, Edit, WebSearch
+compatibility: Codex, Claude Code, Cursor, GitHub Copilot, Windsurf, Kiro, and other Agent Skills compatible tools. Requires git, gh, and the target platform's release toolchain (fastlane, Xcode CLI, Garmin SDK, or npm with semantic-release).
+metadata:
+  targets: [_source-only]
+  author: Oleg Koval
+  tags:
+    - release
+    - ios
+    - android
+    - garmin
+    - app-store
+    - changelog
+    - store-listing
+    - semantic-release
+    - deployment
+    - automation
+source: weekly-pattern-learner
+source_reason: "changelog-generator, store-listing-copy, and apple-store-submit each reference each other in their Chaining tables but no skill chains them into a single end-to-end release-day workflow"
+source_date: "2026-08-10"
+---
+
+> 🤖 *Auto-generated by **weekly-pattern-learner** · changelog-generator, store-listing-copy, and apple-store-submit each reference each other in their Chaining tables but no skill chains them into a single end-to-end release-day workflow*
+
+# Release Day
+
+Drive a release from "code is ready" to "build submitted" in one orchestrated pass.
+Each phase validates its output before proceeding — the skill stops and reports
+rather than pushing a broken release.
+
+## Inputs
+
+- **Platform** (required): `ios`, `android`, `garmin`, or `all`
+- **Version** (optional): explicit version to release; if omitted, semantic-release
+  determines the next version automatically
+- **Branch** (optional, default: `main`): branch to release from
+- **--dry-run** (optional): run all checks and generate all copy without pushing
+  the tag or submitting to the store
+
+## Phase 1 — Verify the branch is ready
+
+```bash
+BRANCH="${Branch:-main}"
+git fetch origin "$BRANCH"
+BRANCH_SHA=$(git rev-parse "origin/$BRANCH")
+
+# Validate optional Version input
+if [ -n "$Version" ]; then
+  if ! echo "$Version" | grep -qE '^v?[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.]+)?$'; then
+    echo "Error: Version '$Version' is not a valid SemVer (e.g. 1.2.3 or v1.2.3)" >&2
+    exit 1
+  fi
+fi
+
+git status --short
+
+# Last release tag
+LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "none")
+
+# Commits since last release
+if [ "$LAST_TAG" = "none" ]; then
+  git log "origin/$BRANCH" --oneline --no-merges | head -20
+else
+  git log "${LAST_TAG}..origin/$BRANCH" --oneline --no-merges | head -20
+fi
+
+# CI state on branch
+gh run list --branch "$BRANCH" --limit 3 --json status,conclusion,workflowName \
+  --jq '.[] | "\(.workflowName): \(.conclusion // .status)"'
+```
+
+**Stop if:**
+- `git status --short` is non-empty — there are uncommitted changes
+- The latest CI run on main is failing or still in progress
+- There are zero commits since the last tag (nothing to release)
+
+Report the problem clearly and stop — do not proceed to a release if the branch
+is not clean and green.
+
+## Phase 2 — Generate changelog
+
+Run `olko:changelog-generator`.
+
+Use the range `${LAST_TAG}..origin/${BRANCH}` (or `origin/${BRANCH}` if no prior tag exists). Produce a
+structured changelog with sections: New Features, Improvements, Bug Fixes, Breaking
+Changes. Strip internal commits (refactor, test, ci, chore without behavior impact).
+
+Write the changelog to:
+```bash
+RELEASE_DIR="$(mktemp -d)/release-$(date +%Y-%m-%d)"
+mkdir -p "$RELEASE_DIR"
+# changelog-generator writes to CHANGELOG.md — validate before proceeding
+if [ ! -s CHANGELOG.md ]; then
+  echo "Error: CHANGELOG.md is missing or empty — cannot continue." >&2
+  exit 1
+fi
+cp CHANGELOG.md "$RELEASE_DIR/changelog.md"
+```
+
+Review the generated changelog for accuracy before continuing. If commits are
+ambiguous (e.g. `fix: thing`), use `git show <sha>` to read the diff and
+re-classify the entry.
+
+## Phase 3 — Draft store listing copy
+
+Run `olko:store-listing-copy` with `--platform <platform>`.
+
+This reads the changelog from Phase 2 and drafts:
+- iOS: Title, Subtitle, What's New (4000 chars), Keywords (100 chars)
+- Android: Title (30), Short Description (80), Release Notes (500)
+- Garmin: Description, What's New (1500 chars)
+
+The skill validates field lengths and known store-validator rules (e.g., no `<`/`>` in
+Garmin copy) before delivering. Output goes to:
+```
+store-copy-v<version>-<YYYY-MM-DD>.md
+```
+
+**Do not proceed until store copy passes validation.** Fix any overflow or forbidden
+character before tagging.
+
+## Phase 4 — Trigger the release
+
+### If semantic-release is configured
+
+```bash
+# Dry-run first to confirm version and release notes
+set -o pipefail
+if ! npm run release:dry-run 2>&1 | tail -40; then
+  echo "Dry-run failed — aborting release." >&2
+  exit 1
+fi
+
+# On confirmation (or with --dry-run: stop here)
+git push origin "$BRANCH"   # trigger CI which runs semantic-release
+```
+
+Wait for the GitHub Actions release workflow to complete:
+
+```bash
+# Capture run ID for the push commit so we poll the right run
+sleep 10
+RUN_ID=$(gh run list --branch "$BRANCH" --workflow ci-release.yml --limit 1 \
+  --json databaseId,headSha \
+  --jq "[.[] | select(.headSha == \"$BRANCH_SHA\")] | .[0].databaseId")
+
+# Poll until the targeted run is done (timeout: 15 min)
+STATUS="pending"
+for i in $(seq 1 30); do
+  STATUS=$(gh run view "$RUN_ID" --json conclusion \
+    --jq '.conclusion // "pending"' 2>/dev/null || echo "pending")
+  [ "$STATUS" = "success" ] && break
+  [ "$STATUS" = "failure" ] || [ "$STATUS" = "cancelled" ] || [ "$STATUS" = "timed_out" ] && \
+    echo "Release workflow ended with status: $STATUS" && exit 1
+  sleep 30
+done
+if [ "$STATUS" != "success" ]; then
+  echo "Release workflow timed out after 15 minutes." >&2
+  exit 1
+fi
+```
+
+### If releasing manually (no semantic-release)
+
+```bash
+# Determine next version (follow SemVer: breaking → major, new feature → minor, fix → patch)
+NEXT_VERSION="vX.Y.Z"  # fill in based on changelog analysis
+
+# Tag and push
+git tag -a "$NEXT_VERSION" -m "Release $NEXT_VERSION"
+git push origin "$NEXT_VERSION"
+
+# Create GitHub release
+gh release create "$NEXT_VERSION" \
+  --title "$NEXT_VERSION" \
+  --notes-file "$RELEASE_DIR/changelog.md"
+```
+
+## Phase 5 — Confirm build artifact
+
+Download and validate the platform-specific build artifact. Poll every 2 minutes
+(timeout: 20 min) — do not proceed to Phase 6 until the artifact is confirmed present.
+
+```bash
+ARTIFACT_FOUND=false
+for i in $(seq 1 10); do
+  gh run download "$RUN_ID" --dir "$RELEASE_DIR" 2>/dev/null || true
+
+  case "$Platform" in
+    ios)
+      IPA=$(find "$RELEASE_DIR" -name "*.ipa" | head -1)
+      [ -n "$IPA" ] && ARTIFACT_FOUND=true && echo "iOS artifact: $IPA" && break
+      ;;
+    android)
+      APK=$(find "$RELEASE_DIR" \( -name "*.apk" -o -name "*.aab" \) | head -1)
+      [ -n "$APK" ] && ARTIFACT_FOUND=true && echo "Android artifact: $APK" && break
+      ;;
+    garmin)
+      PRG=$(find "$RELEASE_DIR" dist -name "*.prg" 2>/dev/null | head -1)
+      [ -n "$PRG" ] && ARTIFACT_FOUND=true && echo "Garmin artifact: $PRG" && break
+      ;;
+    all)
+      IPA=$(find "$RELEASE_DIR" -name "*.ipa" | head -1)
+      APK=$(find "$RELEASE_DIR" \( -name "*.apk" -o -name "*.aab" \) | head -1)
+      PRG=$(find "$RELEASE_DIR" dist -name "*.prg" 2>/dev/null | head -1)
+      [ -n "$IPA" ] && [ -n "$APK" ] && [ -n "$PRG" ] && ARTIFACT_FOUND=true && break
+      ;;
+  esac
+
+  echo "Attempt $i/10: artifact not yet available — waiting 2 minutes..."
+  sleep 120
+done
+
+if [ "$ARTIFACT_FOUND" != "true" ]; then
+  echo "Error: required build artifact not found after 20 minutes — aborting." >&2
+  exit 1
+fi
+```
+
+## Phase 6 — Submit to the store
+
+**Skip this phase with `--dry-run`** — stop after Phase 3 and print the store copy
+for manual paste.
+
+Run the platform-specific submission workflow with the artifact from Phase 5:
+
+**iOS:** Run `olko:apple-store-submit` — handles `altool` / `xcrun notarytool`
+submission, watches for Apple's processing email, and catches common rejection patterns.
+
+**Android:** Upload the `.aab` (or `.apk`) to Google Play using `fastlane supply`:
+
+```bash
+fastlane supply \
+  --aab "$APK" \
+  --track internal \
+  --package_name "$(cat android/app/build.gradle | grep applicationId | awk '{print $2}' | tr -d '"')"
+```
+
+Promote from internal → production after QA sign-off.
+
+**Garmin:** Run `olko:garmin-watchface` store publishing workflow — uploads the `.prg`
+and the listing copy from Phase 3 via the Connect IQ developer portal.
+
+**all:** Run iOS → Android → Garmin in sequence; report each result independently.
+
+## Final report
+
+```
+Release day complete — YYYY-MM-DD
+
+  Version:      vX.Y.Z (was vA.B.C)
+  Platform:     ios / android / garmin / all
+  Changelog:    N features, M fixes, K improvements
+  Store copy:   validated ✓ (all fields within limits)
+  Release:      tagged + GitHub Release created ✓
+  Build:        CI green, artifact downloaded ✓
+  Submission:   queued for App Store / Google Play / Connect IQ review
+
+  Next:
+    - Check Apple / Google / Garmin review status in 24–72h
+    - Monitor crash rates via Crashlytics / Firebase after rollout
+    - Run /review-past-performance at end of day to capture release learnings
+```
+
+## Safety guardrails
+
+- Never push a tag or trigger a release if Phase 1 fails
+- Never submit a store build without a validated Phase 3 output
+- Always `--dry-run` first on a new repo or a new platform
+- Keep the store copy file in $RELEASE_DIR until the submission is confirmed live
+
+## Chaining
+
+| Before this skill | After this skill |
+|---|---|
+| `olko:pr-to-green` — merge the release PR | Monitor store review status |
+| `olko:semantic-release-beta` — promote beta to stable | `olko:changelog-generator` for next iteration |
+| Manual: "all features are in, ship it" | Post-release monitoring |

package/packages/software-development/release-day/adapters/claude/plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "olko-release-day",
+  "description": "Orchestrate a full release-day workflow for iOS, Android, or Garmin apps: verify main branch CI is green, generate changelog, draft platform-ready store listing copy, trigger semantic-release or tag manually, wait for the build, and queue the App Store submission.",
+  "skills": "./skills"
+}