just-vibe 0.7.0

package/plugins/just-vibe/skills/design/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: design
+description: "Develop a visual direction and implement the requested interface Use for a new visual direction and requested interface; polish improves an established direction and ui-system defines reusable tokens."
+---
+
+# design
+
+Develop a visual direction and implement the requested interface
+
+## Choose this workflow
+
+Use for a new visual direction and requested interface; polish improves an established direction and ui-system defines reusable tokens.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [General methods](../../references/packs/general.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply for a requested interface; plan for concept-only requests. Inputs include audience, page/flow, content, references, and stack.
+
+Resolve the user brief and inspect the relevant project or supplied evidence. External capabilities are optional unless the selected action actually needs them.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Requested visual direction and interface, using the existing design system where applicable.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+- Inspect current UI, define hierarchy and states, implement a coherent direction, and inspect the rendered result across relevant sizes.
+- Infer hierarchy from real content and user actions; reuse project primitives, choose a coherent composition and render the primary and failure states.
+
+## Decision branches
+
+- **When references conflict with required content or accessibility:** Explain the concrete conflict and preserve the usable content hierarchy.
+
+## Deliver and verify
+
+- Interface or requested concept, design rationale, and visual/interaction evidence.
+- Implemented interface, visual decisions, inspected states/viewports and remaining visual gaps.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Primary action and content hierarchy are clear; narrow screens and error states remain usable.
+
+## Stop and recover
+
+- Do not invent product claims or replace established branding without basis. Report unavailable visual verification.
+
+## Example requests
+
+- **Normal (apply):** Build the account settings page using our existing typography and controls.
+- **edge (apply):** Design a dense settings page with long translations and destructive actions.
+- **blocked (inspect):** Propose a direction from supplied screenshots when a browser cannot render the app.

package/plugins/just-vibe/skills/do/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: do
+description: "Use the goal and project context to select, execute, and verify appropriate workflows Alias for auto."
+---
+
+# do
+
+Read [auto](../auto/SKILL.md) and execute that single canonical workflow. It owns selection, inputs, mode, scope, methods, outputs, recovery, and verification. Preserve the complete appended request and original invoked name (do); use auto as the canonical command in run records. Do not add a routing stage, change permissions, or reset counters for an alias. This entry deliberately contains no independent behavioral contract.

package/plugins/just-vibe/skills/docs/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: docs
+description: "Create or update documentation from verified behavior Use to maintain source-backed usage documentation; teach explains concepts interactively."
+---
+
+# docs
+
+Create or update documentation from verified behavior
+
+## Choose this workflow
+
+Use to maintain source-backed usage documentation; teach explains concepts interactively.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [General methods](../../references/packs/general.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply; documentation target, audience, and relevant code behavior.
+
+Resolve the user brief and inspect the relevant project or supplied evidence. External capabilities are optional unless the selected action actually needs them.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Accurate usage, interfaces, and maintenance guidance; no invented features or changes outside the named documentation scope.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+- Inspect implementation and examples, update explanations and links, keep terminology consistent, and verify executable examples where authorized.
+- Check documented commands, defaults and examples against current implementation; edit source documents rather than generated copies.
+
+## Decision branches
+
+- **When examples need credentials or destructive execution:** Validate syntax or a controlled substitute and label the live example unexercised.
+
+## Deliver and verify
+
+- Updated documentation and evidence for examples or clear unverified labels.
+- Updated topics, verified examples, compatibility scope and unverified instructions.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A documented command exists with the described behavior; deprecated behavior is not presented as current.
+
+## Stop and recover
+
+- Exclude secrets and private data. Flag ambiguous product policy instead of filling it with plausible prose.
+
+## Example requests
+
+- **Normal (apply):** Update setup instructions to match the scripts that exist today.
+- **edge (apply):** Update docs after a flag was renamed while preserving migration guidance.
+- **blocked (inspect):** Audit documentation against source with no service credentials.

package/plugins/just-vibe/skills/doctor/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: doctor
+description: "Diagnose installation and configuration problems Use to diagnose installed toolkit state; setup intentionally changes installation."
+---
+
+# doctor
+
+Diagnose installation and configuration problems
+
+## Choose this workflow
+
+Use to diagnose installed toolkit state; setup intentionally changes installation.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [General methods](../../references/packs/general.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; just-vibe host, installation source, and scope. Requires host CLI discovery.
+
+Resolve the user brief and inspect the relevant project or supplied evidence. External capabilities are optional unless the selected action actually needs them.
+
+Resolve any task-specific tools, target identity and evidence before dependent actions. No external connection is assumed.
+
+## Scope
+
+Installation/configuration diagnosis; repairs go through an explicitly requested setup/update operation.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+1. Resolve the bundled installer, then run its doctor operation for the requested host, source and Claude scope. Infer the active host only when unambiguous; --local means a complete persistent source checkout.
+2. Report actual prerequisite, marketplace, installation and enablement results. Do not run setup/update or edit configuration to make a status question pass. Unknown inventory formats and conflicts remain actionable blockers.
+
+Task-specific method: Check prerequisites, marketplace identity, inventory format, installation and enablement, and report the first actionable mismatch without changing settings. Compare marketplace source, payload version and native enabled state for the selected host and scope; stop at the first actionable identity mismatch.
+
+## Decision branches
+
+- **When wrapper reports success but host cache is stale:** Report the mismatch and exact update/check sequence; do not call the installation healthy.
+
+## Deliver and verify
+
+- Status, evidence, and exact remedy for each diagnosed problem.
+- Host/scope/source/version observations and remedies with unverified states explicit.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Disabled and absent plugins are distinguished; an unexpected marketplace source blocks a healthy result.
+
+## Stop and recover
+
+- Unknown host output is not guessed. Never delete caches or edit global configuration as an automatic diagnostic step.
+
+## Example requests
+
+- **Normal (inspect):** Check the Claude project-scope just-vibe installation without changing it.
+- **edge (inspect):** Diagnose a disabled plugin with a newer payload than the native cache.
+- **blocked (inspect):** Inspect prerequisites when the host executable is missing; do not install it implicitly.

package/plugins/just-vibe/skills/explain/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: explain
+description: "Explain code or behavior at the requested depth Use for what existing code does and why its observed branches matter; use teach for fundamentals or trace for an entire request path."
+---
+
+# explain
+
+Explain code or behavior at the requested depth
+
+## Choose this workflow
+
+Use for what existing code does and why its observed branches matter; use teach for fundamentals or trace for an entire request path.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [General methods](../../references/packs/general.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; symbol, file, behavior, or question plus desired depth. Requires relevant source access.
+
+Resolve the user brief and inspect the relevant project or supplied evidence. External capabilities are optional unless the selected action actually needs them.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Explain the selected behavior and its necessary dependencies; no refactoring or unsolicited repository-wide tutorial.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Locate definitions and callers, inspect important branches, distinguish static inference from observed runtime behavior, and adapt terminology to the brief.
+- Locate the definition and a real caller; walk one concrete input through transformations, outputs, side effects and failure handling with file references.
+
+## Decision branches
+
+- **When explanation depends on configuration or external behavior not supplied:** Separate the source-established path from conditional behavior and name the missing evidence.
+
+## Deliver and verify
+
+- A causal explanation with source links, a concrete example, and relevant caveats.
+- Input-to-output walkthrough, cited source locations, edge path, and unresolved runtime assumptions.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Explains both the normal path and a meaningful edge path; missing runtime configuration remains explicitly unknown.
+
+## Stop and recover
+
+- Request a target only when multiple interpretations materially change the answer. Do not invent business intent from implementation alone.
+
+## Example requests
+
+- **Normal (inspect):** Explain how session refresh works, including expired credentials.
+- **edge (inspect):** Explain how this function handles an empty array and a rejected dependency.
+- **blocked (inspect):** Explain this module from source only; runtime configuration is unavailable.

package/plugins/just-vibe/skills/fix/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: fix
+description: "Reproduce a bug, identify its cause, and verify the fix Use when the requested outcome is correcting a demonstrated defect; debug diagnoses without default edits."
+---
+
+# fix
+
+Reproduce a bug, identify its cause, and verify the fix
+
+## Choose this workflow
+
+Use when the requested outcome is correcting a demonstrated defect; debug diagnoses without default edits.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [General methods](../../references/packs/general.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply; symptom, expected behavior, and reproduction context. Requires source and a reproducible case or reliable failure evidence.
+
+Resolve the user brief and inspect the relevant project or supplied evidence. External capabilities are optional unless the selected action actually needs them.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Correct the demonstrated cause and nearby necessary behavior; no broad cleanup.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+- Read the behavior contract, nearby callers and existing checks before inferring expected behavior from the defective implementation. Separate the reproduced trigger, intended result and compatibility requirements; record conflicting evidence instead of choosing whichever makes the patch easiest.
+- Trace the failing input through validation, state transitions and the observable result. Choose a focused change that corrects the cause and preserves neighboring valid behavior; distinguish missing, null, zero, false and empty values where the contract does.
+- Reproduce the original failure, apply the fix and run relevant checks with actual exit statuses. Where a regression test is warranted, derive its expected result independently from the contract and establish that it detects the defect rather than incidental setup failure.
+
+## Decision branches
+
+- **When the written contract disagrees with the current fallback or coercion:** Treat the discrepancy as part of the bug investigation. Check callers and compatibility evidence; do not encode the old fallback into a new test merely because it already exists.
+- **When failure cannot be reproduced:** Compare environments and choose a discriminating experiment. Label an unverified patch as partial and state which observation would establish the result.
+
+## Deliver and verify
+
+- Trigger, contract evidence, causal location, focused patch, actual before/after checks and remaining uncertainty.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- The original failure no longer occurs; a neighboring valid case stays correct.
+
+## Stop and recover
+
+- If reproduction is unavailable, label hypotheses and investigate without presenting a speculative patch as a verified fix.
+
+## Example requests
+
+- **Normal (apply):** An expired discount crashes checkout. Reproduce and preserve the error format.
+- **edge (apply):** Fix a null-input crash without changing the behavior of a zero-value input.
+- **blocked (inspect):** Diagnose an intermittent crash with no reproduction; do not claim a verified repair.

package/plugins/just-vibe/skills/git-bisect/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: git-bisect
+description: "Locate a regression with a reproducible pass/fail check Use to locate a deterministic regression boundary; debug first establishes a reliable oracle."
+---
+
+# git-bisect
+
+Locate a regression with a reproducible pass/fail check
+
+## Choose this workflow
+
+Use to locate a deterministic regression boundary; debug first establishes a reliable oracle.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Git methods](../../references/packs/git.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply; known good/bad refs, deterministic oracle, and run budget.
+
+Git, exact repository/worktree, and readable refs/index. Record branch, HEAD, staged/unstaged/untracked state before mutation. Preserve unrelated edits and never default to broad staging, hard reset, clean, force push, or history rewriting.
+
+Declared evidence requirements: `git.repo`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Locate a regression in isolated history; no changes to the user's active worktree.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+- Validate endpoints, create/use an isolated worktree, run the bounded pass/fail oracle, distinguish unbuildable revisions as skips, and confirm the candidate.
+- Confirm good/bad endpoints and oracle exit semantics, run in an isolated worktree, treat untestable revisions as skips and retest the candidate and parent.
+- All changes are owned by the user. Add no agent/model self-attribution, AI-generated signature, badge, or agent Co-authored-by trailer to commits, PRs, comments, release notes or messages. Use the existing user Git identity; preserve legitimate human attribution and required third-party notices.
+
+## Decision branches
+
+- **When skipped revisions or flaky outcomes prevent a unique boundary:** Report the candidate range and uncertainty rather than a definite offending commit.
+
+## Deliver and verify
+
+- Culprit or narrowed range, tested revisions, oracle, and cleanup state.
+- Endpoint refs, oracle, tested/skipped revisions and independently confirmed boundary.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A deterministic regression yields a confirmed boundary; flaky or skipped revisions produce qualified results.
+- Review newly prepared commit/PR/message text, including template or hook additions, for agent self-attribution before submission; verify the resulting artifact when available. Do not silently rewrite existing history or remove human credits.
+
+## Stop and recover
+
+- Stop when the oracle is unreliable or budget expires. Never label a skipped build as the regression without evidence.
+
+## Example requests
+
+- **Normal (apply):** Find the regression between these supplied refs using the deterministic fixture; cap at 12 runs.
+- **edge (apply):** Bisect across a dependency migration where intermediate commits do not build.
+- **blocked (inspect):** Plan bisect when the failure is not reproducible; do not move the active checkout.

package/plugins/just-vibe/skills/git-commit/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: git-commit
+description: "Prepare coherent commits with accurate messages and deliberate staging Use for an explicit bounded commit; git-split designs several coherent commits."
+---
+
+# git-commit
+
+Prepare coherent commits with accurate messages and deliberate staging
+
+## Choose this workflow
+
+Use for an explicit bounded commit; git-split designs several coherent commits.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Git methods](../../references/packs/git.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply; intended changes, commit scope, and message preferences. A direct commit request authorizes the bounded commit.
+
+Git, exact repository/worktree, and readable refs/index. Record branch, HEAD, staged/unstaged/untracked state before mutation. Preserve unrelated edits and never default to broad staging, hard reset, clean, force push, or history rewriting.
+
+Declared evidence requirements: `git.repo`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Deliberate staging and commit creation; no push, amend, or unrelated content.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+- Resolve the repository, HEAD, configured user identity and exact requested commit membership. Inspect both the index and worktree, including untracked files; record unrelated staged and unstaged changes before touching the index.
+- Separate intended changes by hunk, not merely path. If a file mixes user staging with the requested fix, use deliberate patch selection or a temporary index based on HEAD; a whole-file add or commit --only can include unrelated worktree content.
+- Review the actual candidate tree and verify it independently when unrelated worktree changes could affect the result. With a temporary index, stage only intended blobs/tests and run the normal commit path with that index so required hooks still run. Preserve a recoverable record of the original real index until post-commit reconciliation succeeds.
+- After committing through a temporary index, reconcile intended committed changes into the real index while retaining unrelated staged hunks. Verify HEAD contains only the intended change, HEAD-to-index retains the user’s staged work, and index-to-worktree retains the user’s unstaged work. Do not blindly restore an old index against the new HEAD.
+- Use the existing user identity and describe the change without agent/model self-attribution or agent Co-authored-by trailers. Inspect actual committed content and message, including hook changes. A failed hook leaves the operation incomplete; inspect state before retrying and never bypass it.
+
+## Decision branches
+
+- **When unrelated changes are staged in a file that also contains the requested fix:** Build a candidate that excludes those hunks and verify all three trees afterward. If hunks depend on each other and membership is genuinely ambiguous, preserve the recoverable state and ask only about that dependency.
+- **When the candidate passes in the mixed worktree but fails in isolation:** Identify the undeclared dependency. Do not claim the commit is verified or silently include unrelated user work to make it pass.
+
+## Deliver and verify
+
+- Commit hash and included scope, candidate-tree verification, actual message/identity, and evidence that unrelated staged, unstaged and untracked work remains.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- The committed tree contains only the requested change and works without unrelated worktree edits. The user’s unrelated HEAD-to-index and index-to-worktree differences survive. Required hooks and attribution checks pass.
+
+## Stop and recover
+
+- Resolve ambiguous pre-staged content before committing. Never disable hooks or change global identity to force success.
+
+## Example requests
+
+- **Normal (apply):** Commit only the verified checkout fix; preserve other staged and unstaged work.
+- **edge (apply):** Commit only the bug fix when the same file contains unrelated staged edits.
+- **blocked (inspect):** Inspect commit readiness with missing identity or a rejected hook; do not bypass either.

package/plugins/just-vibe/skills/git-conflicts/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: git-conflicts
+description: "Resolve conflicts while preserving the intent of both changes Use during a merge/rebase conflict; git-recover restores lost work."
+---
+
+# git-conflicts
+
+Resolve conflicts while preserving the intent of both changes
+
+## Choose this workflow
+
+Use during a merge/rebase conflict; git-recover restores lost work.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Git methods](../../references/packs/git.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply; active merge/rebase/cherry-pick conflicts and intended behavior.
+
+Git, exact repository/worktree, and readable refs/index. Record branch, HEAD, staged/unstaged/untracked state before mutation. Preserve unrelated edits and never default to broad staging, hard reset, clean, force push, or history rewriting.
+
+Declared evidence requirements: `git.repo`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Resolve conflicted paths; continuing/finalizing the Git operation follows the requested scope.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+- Inspect base/ours/theirs and change intent, resolve behavior rather than choose a side wholesale, handle generated files via their source, and verify merged behavior.
+- Read merge base and both sides plus callers; resolve semantic intent, then regenerate derived files from their sources and check the combined behavior.
+- All changes are owned by the user. Add no agent/model self-attribution, AI-generated signature, badge, or agent Co-authored-by trailer to commits, PRs, comments, release notes or messages. Use the existing user Git identity; preserve legitimate human attribution and required third-party notices.
+
+## Decision branches
+
+- **When the sides encode incompatible product policy:** Leave that conflict explicit and resolve independent files while requesting the actual decision.
+
+## Deliver and verify
+
+- Resolved files, rationale for nontrivial choices, tests, and operation state.
+- Resolution rationale per conflict, preserved behaviors and remaining operation state.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Both legitimate feature changes survive; unresolved policy conflicts remain explicit rather than arbitrarily chosen.
+- Review newly prepared commit/PR/message text, including template or hook additions, for agent self-attribution before submission; verify the resulting artifact when available. Do not silently rewrite existing history or remove human credits.
+
+## Stop and recover
+
+- Never abort or reset an operation automatically. Identify unrelated edits before staging resolved files.
+
+## Example requests
+
+- **Normal (apply):** Resolve this merge while preserving both account switching and refresh behavior.
+- **edge (apply):** Resolve a lockfile conflict after compatible dependency changes on both sides.
+- **blocked (inspect):** Inspect a conflict with unknown intended behavior; do not choose ours or theirs blindly.

package/plugins/just-vibe/skills/git-diff/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: git-diff
+description: "Summarize changes by behavior and identify unrelated edits Use to understand changes against specified refs; review evaluates their correctness."
+---
+
+# git-diff
+
+Summarize changes by behavior and identify unrelated edits
+
+## Choose this workflow
+
+Use to understand changes against specified refs; review evaluates their correctness.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Git methods](../../references/packs/git.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; working/index state or exact base/head refs and desired review focus.
+
+Git, exact repository/worktree, and readable refs/index. Record branch, HEAD, staged/unstaged/untracked state before mutation. Preserve unrelated edits and never default to broad staging, hard reset, clean, force push, or history rewriting.
+
+Declared evidence requirements: `git.repo`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Selected changes and their behavioral meaning; no staging or editing.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Resolve refs, inspect rename/binary/submodule metadata, read surrounding context, group by purpose, and identify unrelated edits.
+- Separate index versus HEAD, worktree versus index and branch versus merge-base; resolve the requested comparison before summarizing hunks.
+- All changes are owned by the user. Add no agent/model self-attribution, AI-generated signature, badge, or agent Co-authored-by trailer to commits, PRs, comments, release notes or messages. Use the existing user Git identity; preserve legitimate human attribution and required third-party notices.
+
+## Decision branches
+
+- **When rename, binary or submodule entries appear:** Report their metadata and scope instead of inventing text diffs or flattening submodule changes.
+
+## Deliver and verify
+
+- Diff summary, impacted contracts, notable risks, and files requiring deeper review.
+- Comparison refs, files/hunks grouped by purpose and unrelated changes.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Staged and unstaged changes are not conflated; a binary change is acknowledged without invented contents.
+- Review newly prepared commit/PR/message text, including template or hook additions, for agent self-attribution before submission; verify the resulting artifact when available. Do not silently rewrite existing history or remove human credits.
+
+## Stop and recover
+
+- Missing comparison refs require resolution. Do not assume every change belongs to the current task.
+
+## Example requests
+
+- **Normal (inspect):** Summarize the diff against main and identify unrelated edits.
+- **edge (inspect):** Explain a file with different staged and unstaged edits.
+- **blocked (inspect):** Compare against a missing base ref without guessing main or fetching.

package/plugins/just-vibe/skills/git-recover/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: git-recover
+description: "Investigate reflog and history to recover lost work Use to find and preserve lost Git content; git-conflicts resolves an active operation."
+---
+
+# git-recover
+
+Investigate reflog and history to recover lost work
+
+## Choose this workflow
+
+Use to find and preserve lost Git content; git-conflicts resolves an active operation.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Git methods](../../references/packs/git.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; lost commit/file symptom, approximate event, and repository.
+
+Git, exact repository/worktree, and readable refs/index. Record branch, HEAD, staged/unstaged/untracked state before mutation. Preserve unrelated edits and never default to broad staging, hard reset, clean, force push, or history rewriting.
+
+Declared evidence requirements: `git.repo`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Find recoverable history and prepare non-destructive restoration; no reset by default.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Inspect reflog, refs, stashes, and reachable candidates; compare candidate contents; explain confidence; create a recovery branch/copy only when restoration is requested.
+- Inspect reflog/stash/reachable candidates, compare file contents and preserve the chosen commit with a new ref before any active-branch movement.
+- All changes are owned by the user. Add no agent/model self-attribution, AI-generated signature, badge, or agent Co-authored-by trailer to commits, PRs, comments, release notes or messages. Use the existing user Git identity; preserve legitimate human attribution and required third-party notices.
+
+## Decision branches
+
+- **When the candidate is absent or unreachable evidence is incomplete:** State the recovery limit and avoid cleanup that could reduce recoverability.
+
+## Deliver and verify
+
+- Candidate recovery points and exact preservation/restoration steps or recovered artifact.
+- Candidate identities, confidence, recovered location and preserved current state.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A lost commit can be preserved without moving the active branch; absent recovery evidence is not claimed as recoverable.
+- Review newly prepared commit/PR/message text, including template or hook additions, for agent self-attribution before submission; verify the resulting artifact when available. Do not silently rewrite existing history or remove human credits.
+
+## Stop and recover
+
+- Do not run garbage collection or destructive cleanup during recovery. Preserve current work before any authorized restore.
+
+## Example requests
+
+- **Normal (inspect):** Find a lost commit in reflog without resetting the current branch.
+- **edge (inspect):** Recover a dropped commit without moving the current branch.
+- **blocked (inspect):** Inspect recovery options after missing reflog history; do not promise restoration.

package/plugins/just-vibe/skills/git-split/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: git-split
+description: "Divide a mixed change into understandable commits Use to separate a change into coherent commits; git-commit handles one selected unit."
+---
+
+# git-split
+
+Divide a mixed change into understandable commits
+
+## Choose this workflow
+
+Use to separate a change into coherent commits; git-commit handles one selected unit.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Git methods](../../references/packs/git.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **plan**. Plan; mixed changes or commits and desired grouping. Applying a split requires explicit execution scope.
+
+Git, exact repository/worktree, and readable refs/index. Record branch, HEAD, staged/unstaged/untracked state before mutation. Preserve unrelated edits and never default to broad staging, hard reset, clean, force push, or history rewriting.
+
+Declared evidence requirements: `git.repo`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Separate coherent changes while preserving content; rewriting published history is a distinct action.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Snapshot current state, map hunks to behaviors, identify dependencies, propose commit ordering, and apply authorized grouping with verification.
+- Map hunks to behavior and dependencies, preserve the original patch/index, and validate each proposed intermediate tree in isolation when feasible.
+- All changes are owned by the user. Add no agent/model self-attribution, AI-generated signature, badge, or agent Co-authored-by trailer to commits, PRs, comments, release notes or messages. Use the existing user Git identity; preserve legitimate human attribution and required third-party notices.
+
+## Decision branches
+
+- **When inseparable hunks cross proposed commits:** Adjust boundaries or keep them together rather than producing a broken intermediate commit.
+
+## Deliver and verify
+
+- Split plan or resulting commits plus evidence the final content is preserved.
+- Ordered commit groups, dependency rationale and preservation evidence.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Formatting and functional edits separate cleanly; overlapping hunks retain both intended behaviors.
+- Review newly prepared commit/PR/message text, including template or hook additions, for agent self-attribution before submission; verify the resulting artifact when available. Do not silently rewrite existing history or remove human credits.
+
+## Stop and recover
+
+- Do not rewrite shared history implicitly or lose pre-existing index state. Stop if grouping cannot preserve a buildable dependency order.
+
+## Example requests
+
+- **Normal (plan):** Plan separate formatting and checkout-fix commits without changing shared history.
+- **edge (plan):** Split a refactor and fix that overlap in one function.
+- **blocked (inspect):** Propose a split without permission to rewrite shared history.