e1024kb
UserA Claude Code copilot: flat /wise-* slash commands, a workflow engine, and autonomous git / PR / ticket-planning pipelines.
Categories
Indexed Skills (38)
wise-commit-message
Draft one Conventional-Commits subject line from your pending git changes — both staged (`git diff --cached`) and unstaged-but-modified tracked files (`git diff`) — Jira-scoped (e.g. `feat(PROJ-777): …`) when a key is detectable from the branch, diff, recent commits, or the live session, and unscoped (e.g. `feat: …`) otherwise. Pass `--copy` to also drop the subject onto the macOS clipboard. Strictly read-only against git — never runs `git commit`, `git add`, or anything that mutates the repo. Invoked as `/wise-commit-message` (bare alias) or `/wise:wise-commit-message` (canonical). Use when the user says "write a commit message", "draft a commit", "conventional commit", "prepare commit message", "one-line commit", or types `/wise-commit-message`.
wise-commit-push
Sweep every working-tree change into the index (`git add -A` — modifications, deletions, and new untracked files), draft a Conventional-Commits subject from the staged diff, run `git commit`, then `git push` to the tracked upstream. If the working tree is already clean but the local branch is ahead of upstream (e.g. a previous skill already committed), skips the commit half and just pushes the existing local commits — the operator types one slash command either way. Refuses to push to `main` / `master` (commit lands locally; push is on the operator) and refuses `--force`, `--force-with-lease`, `--no-verify` entirely. Invoked as `/wise-commit-push` (bare alias) or `/wise:wise-commit-push` (canonical). Use whenever the user says "commit and push", "ship this", "push my changes", "commit and ship", "push the lint commit", or types `/wise-commit-push`. For local-only commits use `/wise-commit` instead; for read-only subject drafting use `/wise-commit-message`.
wise-commit
Sweep every working-tree change into the index (`git add -A` — modifications, deletions, and new untracked files), draft a Conventional-Commits subject from the staged diff (Jira-scoped when a key is detectable from the branch / diff / log / session), and run `git commit`. Closes the loop that `/wise-commit-message` opens — that one drafts and hands the subject back to the user; `/wise-commit` drafts AND commits. Invoked as `/wise-commit` (bare alias) or `/wise:wise-commit` (canonical). Strictly local — never pushes (use `/wise-commit-push` for that), never amends, never bypasses hooks. Use whenever the user says "commit", "commit changes", "make a commit", "commit my work", or types `/wise-commit`.
wise-feedback
Open a GitHub issue in e1024kb/wise-claude reporting feedback, a bug, or a suggestion about a wise skill or workflow — the submitter's environment (OS, Claude Code version, gh version, the cwd's public git remote as org/repo) is auto-captured and the Problem / Summary / Proposal sections are drafted from the user's prompt and the live session's signal about the misbehaving component. Assigns to `e1024kb` and labels `feedback`. Invoked as `/wise-feedback` (bare alias) or `/wise:wise-feedback` (canonical). Use when the user says "feedback", "report a bug", "file an issue", "this skill did a bad job", "the workflow got stuck", "something's wrong with /wise-*", "I have a suggestion", "improvement idea", "open an issue against the marketplace", or types `/wise-feedback`.
wise-insights-mine
Mine your own Claude Code session history for recurring task patterns and, once a pattern recurs across enough distinct sessions, draft it into a reusable personal skill under ~/.claude/skills/ — after you approve each one. This is the wise self-improvement loop: a SessionEnd hook quietly records each finished session into a local ledger, and this command clusters those sessions by frequency and proposes the strongest recurring patterns as new skills. Fully local; nothing leaves your machine. Invoked as `/wise-insights-mine` (bare alias) or `/wise:wise-insights-mine` (canonical). Use when the user says "mine my sessions", "find recurring patterns", "suggest skills", "what should I turn into a skill", "self-improve", or types `/wise-insights-mine`.
wise-insights-refine
Review your learned skills for overlap and consolidate them — merge several redundant or composable skills into one aggregated skill and retire the originals (reversibly), after your approval. The "garden" pass to /wise-insights-mine's "harvest": mine creates skills from recurring sessions, refine keeps the resulting library tidy. Operates only on wise-managed skills (those carrying the wise-insights marker); hand-written skills are never auto-deleted — only suggested. Fully local. Invoked as `/wise-insights-refine` (bare alias) or `/wise:wise-insights-refine` (canonical). Use when the user says "refine my skills", "consolidate skills", "merge overlapping skills", "clean up auto-created skills", "dedupe my skills", or types `/wise-insights-refine`.
wise-insights-reset
Reversibly clean up the self-improvement loop, and roll it back. Snapshots then removes the auto-created (wise-managed) skills and/or the insights index (ledger, candidates, decisions) into a timestamped restore point — and can restore any restore point. Never touches hand-written skills, and never hard-deletes (that's `insights.py purge`). Invoked as `/wise-insights-reset` (bare alias) or `/wise:wise-insights-reset` (canonical). Use when the user says "reset insights", "clean up auto-created skills", "wipe learned skills", "remove the skills mine made", "roll back insights", "restore insights", "undo mine".
wise-profile
Set the session's token-budget profile — low, medium, or max — which every profile-sensitive wise skill and workflow reads at start to scale model tiers, optional research scope, reviewer-panel size, and retry caps. Budget only: it NEVER changes correctness rules (commit conventions, dirty-tree refusals, review gates, push refusals). Bare invocation shows a three-option picker; `/wise-profile low` sets directly. Persists per session (default: medium = the plugin's standard behavior). Invoked as `/wise-profile` (bare alias) or `/wise:wise-profile` (canonical). Use when the user says "set profile", "low budget mode", "token budget", "cheaper runs", "max quality mode", or types `/wise-profile`.
wise-workflow-list
List every workflow available to the wise plugin — both the bundled defaults that ship with the plugin and the user-authored ones under the engine-selected user definition directory. Read-only. Invoked as `/wise-workflow-list` (bare alias) or `/wise:wise-workflow-list` (canonical). Use when the user says "list workflows", "show workflows", "which workflows are available", "what workflows can I run", or types `/wise-workflow-list`.
wise-workflow-remove
Delete a user-authored workflow definition from `the engine-selected user definition directory` — handles both layouts (`<name>/workflow.yaml` folder form AND legacy `<name>.yaml` flat form). Refuses to touch bundled workflows — they ship with the plugin and are replaced by a reinstall, not a remove. Invoked as `/wise-workflow-remove` (bare alias) or `/wise:wise-workflow-remove` (canonical). Use when the user says "remove workflow <name>", "delete workflow <name>", "drop my custom workflow", or types `/wise-workflow-remove`.
wise-workflow-status
Show workflow runs on the wise engine. With no argument, list every run with its status, workflow, start time, cwd and live children. With a run ULID, show that run; when it is gated, show the gate and offer to answer it. Invoked as `/wise-workflow-status` (bare alias) or `/wise:wise-workflow-status` (canonical). Use when the user says "list workflow runs", "show workflow status", "status of my workflow", "which runs are paused", "inspect run <ulid>", or types `/wise-workflow-status`.
wise
wise copilot — natural-language entry point for the whole wise plugin. With no argument, prints the catalog of available `/wise-*` commands plus the reference skills; with free-text (e.g. `/wise open a PR`, `/wise draft a commit message`), classifies the request against the catalog and offers to run the matching command. Use when the user types `/wise` bare (for the help listing) or `/wise <free-form description>` (to find the right command).
wise-estimation
Story-point estimation reference — a Fibonacci 0.5 → 13 SP scale for sizing work across frontend, backend, mobile, and all teams, including how to size uncertain work and the "anything > 8 SP is a research ticket, not an implementation ticket" rule. Use whenever the user says "estimate", "story points", "SP", "size this ticket", "how many points", "t-shirt size", "how long will this take", "break down the estimate", "is this a 3 or a 5", or is planning/refining a Jira ticket and needs a point value.
wise-fork
Reorient the agent after a session fork: inherited context becomes read-only background and pre-fork work stays with the original session. Every in-flight task, plan, and promise from before the fork is dropped, remembered file state is distrusted, and this session starts fresh parallel work - optionally on a new goal passed as the argument. Invoked as `/wise-fork` (bare alias) or `/wise:wise-fork` (canonical). Use when the user says "this is a fork", "forked session", "we branched this conversation", "start fresh but keep context", "don't continue the old work", or types `/wise-fork`.
wise-grill
Deep-research ANY underspecified subject — a tracker ticket (Jira, Linear, GitHub, …), a doc link (Confluence, Notion, RFC, Google Doc), or a free-form prompt / question — across every reachable source: the subject's own comments + screenshots, linked docs, Slack discussions, Google Drive, design files, the codebase and its git history. It classifies the input first, builds a normalized understanding of what the subject actually means, gap-checks the evidence, then forks by type: a ready-to-implement `PLAN-<ref>.md`, a `BLUEPRINT-<ref>.md` with targeted questions (per-person for tickets / docs, asked inline for prompts), or — for a pure question — a researched `ANSWER-<ref>.md`. Re-run with answers to upgrade a blueprint into the plan. Invoked as `/wise-grill` (bare alias) or `/wise:wise-grill` (canonical). Use when the user says "grill this ticket", "grill me", "grill this doc", "what does this ticket actually mean", "research this ticket", "build context around PROJ-123", "research this topic and plan it",
wise-human-writing
Human-first writing rules for EVERY outbound message composed on the user's behalf - ticket descriptions and comments in ANY issue tracker (Jira, Linear, GitHub Issues, GitLab, Asana, Monday, YouTrack, …), PR / MR descriptions, comments, and review replies on ANY code host (GitHub, GitLab, Bitbucket, …), pages and specs in ANY doc system (Confluence, Notion, Google Docs, …), and chat messages (Slack, Teams, Discord, …). ALWAYS consult this skill before drafting or posting any such content, whichever MCP server, CLI, or API is in play: structure every message as context → reasoning → conclusion, write at business level instead of dumping code identifiers, never use ASCII diagrams, and emit the correct native markup per tool. Also invocable as `/wise-human-writing [<draft>]` (bare alias) or `/wise:wise-human-writing` (canonical) to rewrite - "de-slop" - an existing draft without posting it anywhere. Use when creating or updating a ticket, commenting on an issue or PR, posting a status update to Slack, writing a
wise-implement-plan-auto
Autonomously implement a written implementation plan (a `PLAN-*.md` produced by ticket-auto / ticket-plan) in the current git working tree — the plan's task waves are phase gates, each task in a wave is handed to a fresh-context executor agent running in parallel, and every task lands as one atomic commit with per-task verification (type-check / lint / tests). NO prompts. Invoked as `/wise-implement-plan-auto` (bare alias) or `/wise:wise-implement-plan-auto` (canonical). Use when the user says "implement the plan", "execute PLAN-*.md", "build out the plan autonomously", or types `/wise-implement-plan-auto`.
wise-init
Set up wise's Python 3.11+ runtime and managed engine dependencies, check the engine, report provider and connector readiness, and cache the results. GitHub, provider logins, SSH, MCP connectors, and markitdown are optional until a selected action needs them. Preserve earlier skip decisions on repeat runs. Use when the user says "init wise", "set up wise", "install wise deps", "first-time setup", or types /wise-init.
wise-markitdown
File-to-markdown text extraction via Microsoft's `markitdown` CLI — the ONE tool to reach for whenever text/content must be extracted from a binary or structured file: PDF, Word (.docx), PowerPoint (.pptx), Excel (.xlsx/.xls), images (EXIF metadata), audio (metadata + transcription), HTML, CSV/JSON/XML, ZIP archives, EPUB e-books, Outlook .msg, or a YouTube URL. Consult this skill BEFORE writing a custom parser, importing PyPDF2/python-docx/openpyxl, or web-searching "how to read X in Python". Use whenever the user says "extract text from", "read this PDF/DOCX/XLSX/PPTX", "what does this file say", "convert to markdown", "parse this document", "summarize this attachment/report/deck/spreadsheet", or hands over any file of a type above that needs its content read.
wise-pr-add-reviewers
Attach Copilot code review to the PR for the current branch, then prompt the user for individual reviewers (free-text comma-separated logins, with CODEOWNERS-derived candidates and org members shown inline for reference). Idempotent — already-requested reviewers are detected and not re-requested. This skill runs just the reviewer attach step on an existing PR. Fails with a clear message if the current branch has no open PR — run `/wise-pr-create` first. Invoked as `/wise-pr-add-reviewers` (bare alias) or `/wise:wise-pr-add-reviewers` (canonical). Use when the user says "add reviewers", "request review", "ping Copilot", or types `/wise-pr-add-reviewers`.
wise-pr-create-auto
Autonomous variant of `/wise-pr-create` — detect the PR state for the current branch and create or refresh the PR with NO prompts. The body is drafted from the project's PR template; the base branch is chosen autonomously (the repo's default branch) instead of asked. Built for unattended ticket→PR runs. Invoked as `/wise-pr-create-auto` (bare alias) or `/wise:wise-pr-create-auto` (canonical). Use when the user says "create the PR without asking", "auto-create a PR", or types `/wise-pr-create-auto`. For the interactive version (base-branch picker) use `/wise-pr-create`.
wise-pr-create
Detect the PR state for the current branch and either create a new GitHub PR or refresh an existing one — body drafted from the project's `.github/pull_request_template.md` (or a bundled fallback) filled from the branch's diff + commits, Jira key auto-detected from branch/diff/log/session, base branch picked interactively from `main` + recent `release*` branches when creating. This skill runs just the PR create/refresh piece — the `draft-body` + `ensure-pr` steps — without the reviewer + watch loop. Does NOT attach reviewers — use `/wise-pr-add-reviewers` for that — and does NOT watch CI — use `/wise-pr-watch`. Invoked as `/wise-pr-create` (bare alias) or `/wise:wise-pr-create` (canonical). Use when the user says "open a PR", "draft the PR body", "update the PR description", "push this to review", or types `/wise-pr-create`.
wise-pr-request-review-auto
Autonomous variant of `/wise-pr-add-reviewers` — request the bot reviews on the current branch's PR with NO prompts: attach Copilot code review and trigger CodeRabbit (`@coderabbitai review`). It does not enumerate or ask for human reviewers. Idempotent and best-effort — a request failure never blocks. Built for unattended ticket→PR runs. Invoked as `/wise-pr-request-review-auto` (bare alias) or `/wise:wise-pr-request-review-auto` (canonical). Use when the user says "request review without asking", "auto-attach Copilot", or types `/wise-pr-request-review-auto`. For the interactive version (human-reviewer picker) use `/wise-pr-add-reviewers`.
wise-pr-watch-auto
Autonomous variant of `/wise-pr-watch` — drive the current branch's PR to merge in bulk rounds with NO prompts. Each round: one linear 2-minute poll until CI is terminal and every review bot that is going to review the head (Copilot, CodeRabbit) has done so; gather every failing check, every unresolved bot thread (outdated ones included), every open Sonar issue; fix the whole set in one pass, resolve every handled thread immediately, one commit, one push; wait one 2-minute re-review window to see what the push triggered (the push IS the trigger — no `@coderabbitai review` while a bot is auto-reviewing); settle again. Converges on the first head with nothing actionable, or after two nit-only rounds (remaining nits accepted and resolved, no push), or at the round cap. Reads the base branch's rules up front (thread-resolution rule, required approvals), re-reads the PR state at every tick so a PR merged or closed from outside ends the run, and keeps its state under the PR so a re-invocation resumes. A stuck bot g
wise-pr-watch
Watch the current branch's PR and drive it to green: block on `gh pr checks --watch`, classify failing checks (lint / tests / other) and auto-fix them — committing via the shared Conventional-Commits routine — then walk four sequential review queues (humans → Copilot → CodeRabbit → Sonar), each gated by an interactive Paged-bulk / Fix-all / Walk-step-by-step / Skip choice with a phased collect → commit → remote-side-effects → push apply. Surfaces new PR comments each iteration (a reviewer saying "stop autofixing" short-circuits the loop) and exits on all-green — confirmed across two consecutive post-green stability windows so late comments aren't missed — push failure, user abort, or a no-progress safety catch. Runs the shared `watch-pipelines` procedure. Requires an open PR on the current branch. Invoked as `/wise-pr-watch` (bare alias) or `/wise:wise-pr-watch` (canonical). Use when the user says "watch the PR", "drive the pipelines", "fix the failing checks", "babysit CI", or types `/wise-pr-watch`.
wise-prd-architect
Creates and iterates on Product Requirements Documents (PRDs) through structured discovery, parallel brainstorming agents, and collaborative refinement. Use this skill whenever the user mentions PRD, product requirements, product spec, feature spec, product brief, requirements document, or wants to define, scope, or plan a new product or feature. Also triggers when updating, reviewing, continuing, or iterating on an existing PRD. Handles both creating PRDs from scratch and incremental updates to existing ones. Even if the user just says "I have an idea for a product" or "help me think through this feature" — this skill applies.
wise-report
Produce a verified status report of the current session - what is done, what is not, the plan, next steps, open questions, leftovers, and postponed tasks - in compact ref-coded form (F facts, A actions, Q questions, R risks, L leftovers, P postponed), with every claim backed by checkable evidence (git SHA, PR number, file path, test output) or explicitly marked unverified. Pass `--full` for expanded detail, `--save` to also write the report to a handoff file that survives compaction and session end. Invoked as `/wise-report` (bare alias) or `/wise:wise-report` (canonical). Use when the user says "session status", "status report", "where are we", "what's done", "what's left", "summarize the session", "session summary", "what's next", "handoff report", or types `/wise-report`.
wise-revise
Point wise at a scope — a folder, a component, or the whole project — with a free-form improvement intent ("make the API faster", "pay down debt in src/auth", "raise test coverage", or just "improve this"), and it investigates the code read-only, decides what is worth doing, and writes self-contained implementation plans into `docs/plans/` for you to execute later however you choose. The plan is the product: it never edits source and never runs a plan. A panel of read-only roster lenses surfaces findings, the architect vets + ranks them by leverage (impact over effort, weighted by confidence), and each material finding becomes a `PLAN-*.md` in wise's schema — driven straight to a merged PR by the `impl-plan-auto` workflow, run as-is by `/wise-implement-plan-auto`, or filed as a ticket for the `ticket-auto` pipeline. Invoked as `/wise-revise` (bare alias) or `/wise:wise-revise` (canonical). Use when the user says "what should I improve here", "revise this folder / component / project", "find improvements and p
wise-simplify-auto
Autonomously simplify recently-modified code and commit it — dispatches the `code-simplifier` agent over the working tree (cleanup only, behaviour preserved: clarity, consistency, dead-code/redundancy removal), then drafts a Conventional-Commits subject and commits. The lightweight per-commit tier of the plugin's two-tier quality model, as a standalone decision-free building block. NO prompts, never pushes. Invoked as `/wise-simplify-auto` (bare alias) or `/wise:wise-simplify-auto` (canonical). Use when the user says "simplify and commit", "clean up and commit", "run a simplify pass", or types `/wise-simplify-auto`.
wise-skills-create
Scaffold a new skill inside the wise plugin by delegating to Claude Code's skill-creator skill. The new skill lands in `plugins/wise/skills/<name>/`. The plugin hosts two skill shapes: standalone slash-command skills and reference/guidance skills. Any free-form tail the user types after the skill name is forwarded to skill-creator as additional intent. Only runnable from inside a checkout of the wise-claude marketplace repo. Invoked as `/wise-skills-create` (bare alias) or `/wise:wise-skills-create` (canonical). Use when the user says "create a skill", "scaffold a skill", "new skill", "add a skill", or types `/wise-skills-create`.
wise-skills-edit
Edit an existing wise plugin skill by delegating to Claude Code's skill-creator skill with the existing SKILL.md as the target and the wise plugin conventions as guardrails. Locates the skill under `plugins/wise/skills/`. Refuses the `wise` natural-language helper (editing it changes the plugin's discovery surface and must be done in a normal Claude Code session with full repo context). Only runnable from inside a checkout of the wise-claude marketplace repo. Invoked as `/wise-skills-edit` (bare alias) or `/wise:wise-skills-edit` (canonical). Use when the user says "edit a skill", "update a skill", "modify a skill", "change a skill", or types `/wise-skills-edit`.
wise-supervise
Attach a supervisor / watchdog loop to a running team of background agents and keep them on task — automates the manual "ping all your subagents, are you still on track?" nudge. Reads the team's members, actively probes each for its status, nudges any that are idle-but-unfinished or off-goal, and escalates a worker that stays stuck (TaskStop + surface). When the team's workers write heartbeats it also arms a background `stale-workers` Monitor to catch ones hung mid-turn. Invoked as `/wise-supervise` (bare alias) or `/wise:wise-supervise` (canonical), optionally with a team name. Use when the user says "ping all my subagents", "are my agents stuck", "supervise the team", "watch the agents", "nudge the stuck workers", "check my subagents are on track", or types `/wise-supervise`.
wise-tickets
Ticket-writing rules for EVERY ticket composed on the user's behalf in ANY issue tracker (Jira, Linear, GitHub Issues, GitLab, Asana, …) or tracker-like system. ALWAYS consult this skill before creating, editing, updating, splitting, or breaking down a ticket or epic, whichever MCP server, CLI, or API is in play: a ticket is concise and human-readable, never an implementation plan; it follows the canonical sections (Summary, Goal, Scope, Acceptance criteria, References, Labels, Estimate); large work splits per repository/service with sensible aggregation; estimates defer to the wise-estimation scale. Also invocable as `/wise-tickets [<ticket-ref or draft>]` (canonical `/wise:wise-tickets`) to restructure an oversized ticket or draft and, when asked, apply it back to the tracker. Use when creating or updating a ticket or issue, breaking an epic into tickets, or when the user says "create a ticket", "file an issue", "break this down into tickets", "this ticket is too big", or types `/wise-tickets`.
wise-trd-architect
Creates and iterates on Technical Requirements Documents (TRDs) — the engineering counterpart to a PRD. Translates product requirements into architecture decisions, API contracts, data models, and implementation roadmaps. Use this skill when the user mentions TRD, technical design, technical spec, architecture document, engineering design doc, system design, or wants to define HOW to build something. Also triggers for "create a tech spec", "write the architecture", "design the system", or when the user has a PRD and needs the technical plan. Handles both new TRDs from scratch and updates to existing ones.
wise-workflow-create
Scaffold a new workflow through a step-by-step wizard — collects name, description, control mode, inputs, provider tuning, and steps (id, type, type-specific fields, dependencies), previews the generated YAML + README, and writes on confirmation. Writes to `the engine-selected user definition directory<name>/` by default, or offers the bundled `plugins/wise/workflows/<name>/` path when run inside a clone of the marketplace repo. Invoked as `/wise-workflow-create` (bare alias) or `/wise:wise-workflow-create` (canonical). Use when the user says "create a workflow", "scaffold a workflow", "new workflow", "author a workflow", or types `/wise-workflow-create`.
wise-workflow-resume
Resume a paused or failed workflow run on the wise engine, or answer the gate of a gated one, then follow its events in this conversation. Invoked as `/wise-workflow-resume` (bare alias) or `/wise:wise-workflow-resume` (canonical). Use when the user says "resume the workflow", "continue the paused run", "pick up the run", "resume run <ulid>", or types `/wise-workflow-resume`.
wise-workflow-run
Start a workflow run on the wise engine: pre-flight questions, run context from the conversation, one line per engine event, gates. Invoked as `/wise-workflow-run` (bare alias) or `/wise:wise-workflow-run` (canonical). Use when the user says "run the workflow", "kick off <workflow-name>", or types `/wise-workflow-run`.
wise-code-comments
Code-comment rules for EVERY comment and docstring written on the user's behalf in ANY programming language. ALWAYS consult this skill before writing, rewriting, or reviewing a code comment, docstring, or inline annotation - whether adding comments to new code, editing code that carries comments, or when the user says "add comments", "document this function", "comment this code", "explain this in the code", or "clean up the comments". A comment MUST read like a plain-language (ELI5) statement of what the code does or what constraint it obeys RIGHT NOW - concise, present tense, no history, no ticket archaeology.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.