@xevy/skills 0.1.25 → 0.1.29
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.claude-plugin/plugin.json +2 -2
- package/README.md +8 -6
- package/bin/cli.mjs +48 -0
- package/package.json +1 -1
- package/skills/analyze/SKILL.md +55 -15
- package/skills/execute/SKILL.md +61 -19
- package/skills/fix/SKILL.md +49 -15
- package/skills/generate-image/SKILL.md +46 -22
- package/skills/investigate/SKILL.md +1 -1
- package/skills/merge/SKILL.md +53 -13
- package/skills/move-to-qa/SKILL.md +47 -11
- package/skills/plan/SKILL.md +55 -14
- package/skills/analyze-here/SKILL.md +0 -30
- package/skills/execute-here/SKILL.md +0 -36
- package/skills/fix-here/SKILL.md +0 -23
- package/skills/merge-here/SKILL.md +0 -22
- package/skills/move-to-qa-here/SKILL.md +0 -21
- package/skills/plan-here/SKILL.md +0 -26
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "xevy",
|
|
3
3
|
"displayName": "Xevy",
|
|
4
|
-
"description": "Native /xevy:* SDLC workflow commands driven through the Xevy MCP server.
|
|
5
|
-
"version": "0.1.
|
|
4
|
+
"description": "Native /xevy:* SDLC workflow commands driven through the Xevy MCP server. Work runs locally by default; pass --cloud to use the server Web Agent. The coding agent reviews and corrects the result after every action.",
|
|
5
|
+
"version": "0.1.29",
|
|
6
6
|
"author": {
|
|
7
7
|
"name": "Xevy"
|
|
8
8
|
},
|
package/README.md
CHANGED
|
@@ -105,16 +105,18 @@ with `codex mcp add`.
|
|
|
105
105
|
| Skill | Purpose |
|
|
106
106
|
|-------|---------|
|
|
107
107
|
| `setup` | Link repo, `.xevy/project.json`, deploy defaults, env sync |
|
|
108
|
-
| `analyze
|
|
109
|
-
| `plan
|
|
110
|
-
| `execute
|
|
111
|
-
| `fix
|
|
112
|
-
| `merge
|
|
113
|
-
| `move-to-qa
|
|
108
|
+
| `analyze [task] [--cloud]` | Task analysis (local by default) |
|
|
109
|
+
| `plan [task] [--cloud]` | Planning + review (local by default) |
|
|
110
|
+
| `execute [task] [--cloud]` | Build, verify, and open a PR (local by default) |
|
|
111
|
+
| `fix [task] [--cloud]` | Rework after review (local by default) |
|
|
112
|
+
| `merge [task] [--cloud]` | Merge locally by default; `--cloud` lands the remote branch |
|
|
113
|
+
| `move-to-qa [task] [--cloud]` | QA handoff (local by default) |
|
|
114
114
|
| `deploy` | Coolify preview/main |
|
|
115
115
|
| `investigate` | Diagnose with ephemeral scripts (.env; no secrets) |
|
|
116
116
|
| `create-xevy-task` | Capture session work into a task |
|
|
117
117
|
|
|
118
|
+
The six SDLC workflow skills run in the current coding-agent session by default. Add the exact `--cloud` flag before or after the task code to delegate that workflow to Xevy's server agent, for example `execute VI22-01 --cloud`.
|
|
119
|
+
|
|
118
120
|
## Security
|
|
119
121
|
|
|
120
122
|
- **Codex MCP** uses a local bridge and the mode-`600` API key stored by
|
package/bin/cli.mjs
CHANGED
|
@@ -29,6 +29,14 @@ const pkgRoot = path.resolve(here, "..");
|
|
|
29
29
|
|
|
30
30
|
const DEFAULT_BASE = "https://xevy.ai";
|
|
31
31
|
const DEFAULT_AGENTS = ["cursor", "claude-code", "codex"];
|
|
32
|
+
const RETIRED_SKILLS = [
|
|
33
|
+
"analyze-here",
|
|
34
|
+
"plan-here",
|
|
35
|
+
"execute-here",
|
|
36
|
+
"fix-here",
|
|
37
|
+
"merge-here",
|
|
38
|
+
"move-to-qa-here",
|
|
39
|
+
];
|
|
32
40
|
|
|
33
41
|
function usage() {
|
|
34
42
|
console.log(`Xevy skills + MCP installer
|
|
@@ -221,6 +229,43 @@ function installSkills(opts, skillsRoot = pkgRoot) {
|
|
|
221
229
|
run("npx", skillArgs, { label: "npx skills add (Xevy skills)" });
|
|
222
230
|
}
|
|
223
231
|
|
|
232
|
+
function readSkillsLock(opts) {
|
|
233
|
+
const lockPath = opts.global
|
|
234
|
+
? path.join(
|
|
235
|
+
process.env.XDG_STATE_HOME || path.join(os.homedir(), ".agents"),
|
|
236
|
+
...(process.env.XDG_STATE_HOME ? ["skills", ".skill-lock.json"] : [".skill-lock.json"]),
|
|
237
|
+
)
|
|
238
|
+
: path.join(process.cwd(), "skills-lock.json");
|
|
239
|
+
try {
|
|
240
|
+
return JSON.parse(fs.readFileSync(lockPath, "utf-8"));
|
|
241
|
+
} catch {
|
|
242
|
+
return { skills: {} };
|
|
243
|
+
}
|
|
244
|
+
}
|
|
245
|
+
|
|
246
|
+
function isXevySkillSource(source) {
|
|
247
|
+
const normalized = String(source || "").replaceAll("\\", "/").toLowerCase();
|
|
248
|
+
return (
|
|
249
|
+
normalized.includes("@xevy/skills") ||
|
|
250
|
+
normalized.includes("@innotech-ai/skills") ||
|
|
251
|
+
normalized.includes("vytedev/xevy.ai") ||
|
|
252
|
+
normalized.includes("/src/packages/xevy-skills")
|
|
253
|
+
);
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
function removeRetiredSkills(opts) {
|
|
257
|
+
const lock = readSkillsLock(opts);
|
|
258
|
+
const retired = RETIRED_SKILLS.filter((name) =>
|
|
259
|
+
isXevySkillSource(lock?.skills?.[name]?.source),
|
|
260
|
+
);
|
|
261
|
+
if (retired.length === 0) return;
|
|
262
|
+
|
|
263
|
+
const removeArgs = ["--yes", "skills", "remove", ...retired];
|
|
264
|
+
if (opts.global) removeArgs.push("-g");
|
|
265
|
+
removeArgs.push("-y");
|
|
266
|
+
run("npx", removeArgs, { label: "npx skills remove (retired Xevy aliases)" });
|
|
267
|
+
}
|
|
268
|
+
|
|
224
269
|
function installMcp(opts) {
|
|
225
270
|
const mcpUrl = `${opts.base}/mcp`;
|
|
226
271
|
const remoteAgents = opts.agents.filter((agent) => agent !== "codex");
|
|
@@ -426,6 +471,7 @@ async function runCheck(opts) {
|
|
|
426
471
|
|
|
427
472
|
async function runUpdate(opts) {
|
|
428
473
|
await maybeReexecLatestCli(opts);
|
|
474
|
+
removeRetiredSkills(opts);
|
|
429
475
|
|
|
430
476
|
const stamp = readInstalledStamp(process.cwd(), { global: opts.global });
|
|
431
477
|
const { latest } = await resolveLatestVersion(opts);
|
|
@@ -497,6 +543,7 @@ async function main() {
|
|
|
497
543
|
}
|
|
498
544
|
|
|
499
545
|
if (opts.command === "skills") {
|
|
546
|
+
removeRetiredSkills(opts);
|
|
500
547
|
installSkills(opts);
|
|
501
548
|
recordInstallStamp(opts, readPackageVersion());
|
|
502
549
|
}
|
|
@@ -506,6 +553,7 @@ async function main() {
|
|
|
506
553
|
}
|
|
507
554
|
|
|
508
555
|
if (opts.command === "install") {
|
|
556
|
+
removeRetiredSkills(opts);
|
|
509
557
|
installSkills(opts);
|
|
510
558
|
installMcp(opts);
|
|
511
559
|
// Record coverage only after both installers succeed. A failed MCP write
|
package/package.json
CHANGED
package/skills/analyze/SKILL.md
CHANGED
|
@@ -1,26 +1,66 @@
|
|
|
1
1
|
---
|
|
2
2
|
name: analyze
|
|
3
|
-
description: Analyze a task in the
|
|
4
|
-
argument-hint: "[task]"
|
|
3
|
+
description: Analyze a task locally in the current coding-agent session by default — inspect the codebase, write the Analysis section and story points, then self-review. Pass --cloud to delegate analysis to the Xevy server agent, then review and correct its result.
|
|
4
|
+
argument-hint: "[task] [--cloud]"
|
|
5
5
|
disable-model-invocation: true
|
|
6
|
-
allowed-tools: "Read Grep Bash mcp__xevy__find_task mcp__xevy__update_task mcp__xevy__list_specs mcp__xevy__list_subtasks mcp__xevy__start_ai_action mcp__xevy__get_ai_execution mcp__xevy__list_ai_executions"
|
|
6
|
+
allowed-tools: "Read Grep Bash mcp__xevy__find_task mcp__xevy__update_task mcp__xevy__list_specs mcp__xevy__list_subtasks mcp__xevy__list_task_notes mcp__xevy__create_task_note mcp__xevy__list_task_decisions mcp__xevy__create_decision mcp__xevy__answer_decision mcp__xevy__start_ai_action mcp__xevy__get_ai_execution mcp__xevy__list_ai_executions"
|
|
7
7
|
---
|
|
8
8
|
|
|
9
|
-
# /xevy:analyze — analyze in the cloud
|
|
9
|
+
# /xevy:analyze — analyze locally or in the cloud
|
|
10
10
|
|
|
11
|
-
|
|
11
|
+
Local analysis is the default. Pass the exact standalone `--cloud` flag to delegate the analysis to the Xevy server agent.
|
|
12
|
+
|
|
13
|
+
## 0. Choose the engine
|
|
14
|
+
|
|
15
|
+
- Parse `$ARGUMENTS` for the exact standalone `--cloud` token and remove that token before resolving the task. Do not treat similar text such as `--cloudy`, `cloud`, or `--cloud=true` as the flag.
|
|
16
|
+
- Without `--cloud`, follow the **Local workflow** and do not call `start_ai_action`. The missing flag is an explicit instruction to stay local: for the whole run, `mcp__xevy__start_ai_action`, `mcp__xevy__get_ai_execution`, and `mcp__xevy__list_ai_executions` are forbidden, and so is any other way of handing the work to the Xevy server agent.
|
|
17
|
+
- Never infer the cloud engine from context. Task status, an earlier cloud run, an open pull request, an existing execution record, an idle local worktree, urgency, or a local step that turns out to be slow or hard are **not** consent. Only the literal flag selects the Cloud workflow.
|
|
18
|
+
- If the Local workflow cannot be completed, stop and report exactly what is blocking it, then let the user decide whether to rerun with `--cloud`. Never switch engines mid-run and never run both.
|
|
19
|
+
- With `--cloud`, follow the **Cloud workflow** and do not duplicate the work locally beyond the review-and-correct step it defines.
|
|
12
20
|
|
|
13
21
|
## 1. Resolve the task
|
|
14
|
-
Resolve from `$ARGUMENTS` (`mcp__xevy__find_task` by code) or the in-context task. If ambiguous, ask which task.
|
|
15
22
|
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
23
|
+
Resolve the remaining task argument or the in-context task (`mcp__xevy__find_task` / `find_task`). If ambiguous, ask which task. Read existing specs, subtasks, and notes.
|
|
24
|
+
|
|
25
|
+
## 2A. Local workflow (default)
|
|
26
|
+
|
|
27
|
+
### Decisions gate
|
|
28
|
+
|
|
29
|
+
Call `mcp__xevy__list_task_decisions`. If any decision is **open**, resolve it before doing the work: present each open question through the host's user-question mechanism using its preset choices and explanations, record the answer with `mcp__xevy__answer_decision`, and fold the answers into the analysis. Never guess or bypass an open decision.
|
|
30
|
+
|
|
31
|
+
### Inspect the codebase
|
|
32
|
+
|
|
33
|
+
Read the relevant files, including callers, callees, and similar patterns. Identify whether the task involves UI changes; if so, study existing UI patterns and record a `UI/UX Flow` note with `mcp__xevy__create_task_note`. Base decisions on established patterns and ask only about genuine ambiguity.
|
|
34
|
+
|
|
35
|
+
### Write the Analysis
|
|
36
|
+
|
|
37
|
+
Use `mcp__xevy__update_task` to append a `## Analysis` section without replacing the user's original request:
|
|
38
|
+
|
|
39
|
+
- **Overview:** plain-language summary, before/after behaviour, user impact, and key decisions.
|
|
40
|
+
- **Technical Implementation:** affected files/modules, API/data/UI changes, assumptions, risks, and verification approach.
|
|
41
|
+
- Estimate `storyPoints` (1 trivial · 2 small · 3 medium · 5 large · 8 XL · 13 epic) and set it.
|
|
42
|
+
- For a genuine ambiguity that a human must resolve, record it with `mcp__xevy__create_decision` using preset choices and explanations. If the user is present, use the host's user-question mechanism and persist the result with `create_decision` + `answer_decision`.
|
|
43
|
+
|
|
44
|
+
### Review and correct
|
|
45
|
+
|
|
46
|
+
Re-read the Analysis against the actual code. Confirm every claim is accurate, affected files exist, and risks and acceptance criteria are concrete. Fix every gap or inaccuracy before finishing. Call `mcp__xevy__list_task_decisions` again and surface any decision that remains open.
|
|
47
|
+
|
|
48
|
+
Report a PASS/PARTIAL verdict, what you corrected, any open decisions, and the task URL. Do not push the user to the next phase.
|
|
49
|
+
|
|
50
|
+
## 2B. Cloud workflow (`--cloud`)
|
|
51
|
+
|
|
52
|
+
### Run the server action
|
|
53
|
+
|
|
54
|
+
- Call `mcp__xevy__start_ai_action({ taskId, action: "analyze", stream: true })`; always pass `stream: true`. The call blocks and streams live per-step progress, so report progress as it arrives. Do not use fire-and-forget or sleep/manual polling loops.
|
|
55
|
+
- Only if the streamed call returns before a terminal status because of a genuine client disconnect, resume with `mcp__xevy__get_ai_execution` until `succeeded | failed | cancelled` (use `list_ai_executions` to find the newest run if needed).
|
|
56
|
+
- If it fails, read the captured output, report the error, and offer to retry or rerun `/xevy:analyze` without `--cloud`.
|
|
57
|
+
|
|
58
|
+
### Review and correct
|
|
20
59
|
|
|
21
|
-
## 3. Review & correct (MANDATORY — do not finish until clean)
|
|
22
60
|
Act as the reviewer of the cloud result:
|
|
23
|
-
|
|
24
|
-
-
|
|
25
|
-
-
|
|
26
|
-
-
|
|
61
|
+
|
|
62
|
+
- Re-read the task, specs, subtasks, and the Analysis section the agent wrote.
|
|
63
|
+
- Confirm it covers the plain-language overview, before/after behaviour, user impact, affected files, API/data/UI changes, assumptions, risks, verification, and a `storyPoints` estimate. Inspect referenced code with Read/Grep rather than trusting the write-up.
|
|
64
|
+
- Repair missing, inaccurate, or contradictory material with `mcp__xevy__update_task`; append or repair the Analysis and never delete the user's original request. Set `storyPoints` if absent.
|
|
65
|
+
|
|
66
|
+
Report a PASS/PARTIAL verdict, what you corrected, and the task URL. Do not push the user to the next phase.
|
package/skills/execute/SKILL.md
CHANGED
|
@@ -1,29 +1,71 @@
|
|
|
1
1
|
---
|
|
2
2
|
name: execute
|
|
3
|
-
description: Execute a task in the
|
|
4
|
-
argument-hint: "[task]"
|
|
3
|
+
description: Execute a task locally in the current coding-agent session by default — use the task worktree, implement the plan, verify, push, and open a PR. Pass --cloud to delegate implementation to the Xevy server agent, then review and correct its result.
|
|
4
|
+
argument-hint: "[task] [--cloud]"
|
|
5
5
|
disable-model-invocation: true
|
|
6
|
-
allowed-tools: "Read Grep Edit Bash Agent mcp__xevy__find_task mcp__xevy__update_task mcp__xevy__list_subtasks mcp__xevy__list_sprints mcp__xevy__assign_task_to_sprint mcp__xevy__start_ai_action mcp__xevy__get_ai_execution mcp__xevy__list_ai_executions
|
|
6
|
+
allowed-tools: "Read Grep Edit Write Bash Agent mcp__xevy__find_task mcp__xevy__update_task mcp__xevy__update_task_status mcp__xevy__list_specs mcp__xevy__list_subtasks mcp__xevy__update_subtask mcp__xevy__list_sprints mcp__xevy__assign_task_to_sprint mcp__xevy__list_task_decisions mcp__xevy__create_decision mcp__xevy__answer_decision mcp__xevy__start_ai_action mcp__xevy__get_ai_execution mcp__xevy__list_ai_executions set_session_task_lock"
|
|
7
7
|
---
|
|
8
8
|
|
|
9
|
-
# /xevy:execute — execute in the cloud
|
|
9
|
+
# /xevy:execute — execute locally or in the cloud
|
|
10
10
|
|
|
11
|
-
|
|
11
|
+
Local implementation is the default. Pass the exact standalone `--cloud` flag to delegate implementation to the Xevy server agent.
|
|
12
12
|
|
|
13
|
-
##
|
|
14
|
-
- Resolve the task (`$ARGUMENTS` / context). Confirm planning artifacts exist (`list_subtasks`); if none and the task is non-trivial, suggest `/xevy:plan` first.
|
|
15
|
-
- Sprint gate: if an active sprint exists (`list_sprints` status=active) and the task isn't on it, ensure it has `## Analysis` + `storyPoints` > 0, then `assign_task_to_sprint` — else stop and ask the user to analyze/estimate first.
|
|
13
|
+
## 0. Choose the engine
|
|
16
14
|
|
|
17
|
-
|
|
18
|
-
-
|
|
19
|
-
-
|
|
15
|
+
- Parse `$ARGUMENTS` for the exact standalone `--cloud` token and remove that token before resolving the task. Do not treat similar text such as `--cloudy`, `cloud`, or `--cloud=true` as the flag.
|
|
16
|
+
- Without `--cloud`, follow the **Local workflow** and do not call `start_ai_action`. The missing flag is an explicit instruction to stay local: for the whole run, `mcp__xevy__start_ai_action`, `mcp__xevy__get_ai_execution`, and `mcp__xevy__list_ai_executions` are forbidden, and so is any other way of handing the work to the Xevy server agent.
|
|
17
|
+
- Never infer the cloud engine from context. Task status, an earlier cloud run, an open pull request, an existing execution record, an idle local worktree, urgency, or a local step that turns out to be slow or hard are **not** consent. Only the literal flag selects the Cloud workflow.
|
|
18
|
+
- If the Local workflow cannot be completed, stop and report exactly what is blocking it, then let the user decide whether to rerun with `--cloud`. Never switch engines mid-run and never run both.
|
|
19
|
+
- With `--cloud`, follow the **Cloud workflow** and do not duplicate the work locally beyond the review-and-correct step it defines.
|
|
20
20
|
|
|
21
|
-
##
|
|
22
|
-
Do NOT finish until the change is verified and correct:
|
|
23
|
-
- `git fetch origin` and check out / diff the task's feature branch (read the branch from `find_task` → pull request metadata). Inspect the full diff against the task requirements and plan (trace each requirement to code).
|
|
24
|
-
- Run the project's checks (type-check, lint, tests). Read failures; if anything is broken, incomplete, or violates a "must NOT" constraint, **fix it**: edit the files, then commit + push to the **feature branch** (never a protected branch). You may dispatch the **reviewer** subagent for an independent pass.
|
|
25
|
-
- **Frontend/UI changes:** before editing any UI (pages, components, app shell, forms, styling), follow the `/xevy:xevy-design` skill so the change matches the project design system (`./.xevy/design.md`).
|
|
26
|
-
- Re-run checks until green. Refresh the PR. Summarise PASS/PARTIAL/FAIL with file:line evidence and what you corrected.
|
|
21
|
+
## 1. Resolve and apply common gates
|
|
27
22
|
|
|
28
|
-
|
|
29
|
-
-
|
|
23
|
+
- Resolve the remaining task argument or the in-context task. Read its `## Analysis`, plan spec, and subtasks. If planning artifacts are absent and the task is non-trivial, suggest `/xevy:plan` or ask whether to plan-and-execute or execute directly.
|
|
24
|
+
- Sprint gate: if an active sprint exists and the task is not on it, require `## Analysis` and `storyPoints` greater than zero, then call `assign_task_to_sprint`; otherwise stop and ask the user to analyze and estimate first.
|
|
25
|
+
|
|
26
|
+
## 2A. Local workflow (default)
|
|
27
|
+
|
|
28
|
+
### Decisions gate
|
|
29
|
+
|
|
30
|
+
Call `mcp__xevy__list_task_decisions` before implementing. If any decision is **open**, present it through the host's user-question mechanism, record the answer with `mcp__xevy__answer_decision`, and fold it into the work. If a relevant subtask is already done, the answer may require a new subtask. Never guess or bypass an open decision.
|
|
31
|
+
|
|
32
|
+
### Worktree protocol
|
|
33
|
+
|
|
34
|
+
- Record the current branch and directory. Derive a canonical branch `xevy/<TASK-ID>-<slug>` using the task code or the first eight characters of its UUID. Reuse an existing task branch; never create a second branch for the same task.
|
|
35
|
+
- Create or attach a git worktree in a sibling directory and change into it. When resuming, first merge the latest source branch (for example `git merge origin/main`). Do all work in the task worktree.
|
|
36
|
+
- In Pi, call `set_session_task_lock(taskCode, taskId, taskTitle, worktreePath, branch)` immediately after attaching the worktree, using the absolute `git rev-parse --show-toplevel` path. If the tool is unavailable, continue while keeping the worktree rules.
|
|
37
|
+
- Never commit or push on a protected branch (`master`, `main`, `develop`, `staging`); use only the `xevy/*` task branch.
|
|
38
|
+
|
|
39
|
+
### Implement
|
|
40
|
+
|
|
41
|
+
- Move the task to `in_progress` with `update_task_status` when implementation begins. This mirrors cloud execution, which moves to `in_progress` at start and `for_review` on success.
|
|
42
|
+
- Work through subtasks in order. When useful and supported, dispatch builder/frontend subagents with the worktree as their working directory. Keep changes surgical, match existing style, and update subtask status through MCP.
|
|
43
|
+
- Before editing UI pages, components, app shell, forms, or styling, follow `/xevy:xevy-design` and the project's `./.xevy/design.md`.
|
|
44
|
+
- If a genuine human decision appears mid-implementation, record it with `mcp__xevy__create_decision` using preset choices rather than guessing. If the user is present, persist their answer with `create_decision` + `answer_decision`.
|
|
45
|
+
- Validate after each step: type-check, lint, then targeted tests.
|
|
46
|
+
|
|
47
|
+
### Review, push, and hand off
|
|
48
|
+
|
|
49
|
+
- Run the full project checks. Trace every requirement to code and verify every “must NOT” constraint. When supported, dispatch a **reviewer** for an independent PASS/PARTIAL/FAIL with file:line evidence; otherwise do a separate review pass. Fix all findings and re-run checks until green.
|
|
50
|
+
- Commit and push the task branch. Open or refresh the PR and always give the user its PR or compare link. Do not merge automatically.
|
|
51
|
+
- Record the branch on the task in `aiPullRequest.branch`, then move the task to `for_review` with `update_task_status`.
|
|
52
|
+
- Do not deploy Preview automatically. Preview is an explicit user action via `/xevy:deploy preview`.
|
|
53
|
+
|
|
54
|
+
## 2B. Cloud workflow (`--cloud`)
|
|
55
|
+
|
|
56
|
+
### Run the server action
|
|
57
|
+
|
|
58
|
+
- Call `mcp__xevy__start_ai_action({ taskId, action: "execute", stream: true })`; always pass `stream: true`. Report live per-step progress as it arrives. Do not use fire-and-forget or sleep/manual polling loops.
|
|
59
|
+
- Only if the streamed call returns before a terminal status because of a genuine disconnect, resume with `mcp__xevy__get_ai_execution` (use `list_ai_executions` if needed).
|
|
60
|
+
- On failure, surface the captured output and offer to retry or rerun `/xevy:execute` without `--cloud`.
|
|
61
|
+
- On success, the server has pushed the feature branch and opened a PR recorded on the task.
|
|
62
|
+
|
|
63
|
+
### Review and correct
|
|
64
|
+
|
|
65
|
+
- Fetch origin and inspect the task's feature branch using the pull-request metadata from `find_task`. Trace every requirement in the task and plan to the full diff.
|
|
66
|
+
- Run the project's type-check, lint, and tests. Fix anything broken, incomplete, or contrary to a “must NOT” constraint; commit and push corrections to the feature branch, never a protected branch. When useful, dispatch a **reviewer** for an independent pass.
|
|
67
|
+
- Before correcting UI code, follow `/xevy:xevy-design` and the project's `./.xevy/design.md`.
|
|
68
|
+
- Re-run checks until green and refresh the PR. Report PASS/PARTIAL/FAIL with file:line evidence and corrections made.
|
|
69
|
+
- Do not deploy Preview automatically. Preview is an explicit user action via `/xevy:deploy preview`.
|
|
70
|
+
|
|
71
|
+
Report the PR and verification result.
|
package/skills/fix/SKILL.md
CHANGED
|
@@ -1,26 +1,60 @@
|
|
|
1
1
|
---
|
|
2
2
|
name: fix
|
|
3
|
-
description: Apply a fix
|
|
4
|
-
argument-hint: "[task]"
|
|
3
|
+
description: Apply a task fix locally in the current coding-agent session by default — reuse its worktree, rework, verify, push, and refresh the PR. Pass --cloud to delegate the fix to the Xevy server agent, then review and correct its result.
|
|
4
|
+
argument-hint: "[task] [--cloud]"
|
|
5
5
|
disable-model-invocation: true
|
|
6
|
-
allowed-tools: "Read Grep Edit Bash Agent mcp__xevy__find_task mcp__xevy__start_ai_action mcp__xevy__get_ai_execution mcp__xevy__list_ai_executions
|
|
6
|
+
allowed-tools: "Read Grep Edit Write Bash Agent mcp__xevy__find_task mcp__xevy__update_task mcp__xevy__list_subtasks mcp__xevy__update_subtask mcp__xevy__start_ai_action mcp__xevy__get_ai_execution mcp__xevy__list_ai_executions"
|
|
7
7
|
---
|
|
8
8
|
|
|
9
|
-
# /xevy:fix — fix in the cloud
|
|
9
|
+
# /xevy:fix — fix locally or in the cloud
|
|
10
10
|
|
|
11
|
-
|
|
11
|
+
Local rework is the default. Pass the exact standalone `--cloud` flag to delegate the fix to the Xevy server agent.
|
|
12
|
+
|
|
13
|
+
## 0. Choose the engine
|
|
14
|
+
|
|
15
|
+
- Parse `$ARGUMENTS` for the exact standalone `--cloud` token and remove that token before resolving the task. Do not treat similar text such as `--cloudy`, `cloud`, or `--cloud=true` as the flag.
|
|
16
|
+
- Without `--cloud`, follow the **Local workflow** and do not call `start_ai_action`. The missing flag is an explicit instruction to stay local: for the whole run, `mcp__xevy__start_ai_action`, `mcp__xevy__get_ai_execution`, and `mcp__xevy__list_ai_executions` are forbidden, and so is any other way of handing the work to the Xevy server agent.
|
|
17
|
+
- Never infer the cloud engine from context. Task status, an earlier cloud run, an open pull request, an existing execution record, an idle local worktree, urgency, or a local step that turns out to be slow or hard are **not** consent. Only the literal flag selects the Cloud workflow.
|
|
18
|
+
- If the Local workflow cannot be completed, stop and report exactly what is blocking it, then let the user decide whether to rerun with `--cloud`. Never switch engines mid-run and never run both.
|
|
19
|
+
- With `--cloud`, follow the **Cloud workflow** and do not duplicate the work locally beyond the review-and-correct step it defines.
|
|
12
20
|
|
|
13
21
|
## 1. Resolve
|
|
14
|
-
Resolve the task (`$ARGUMENTS` / context). It should already have a feature branch from a prior execute.
|
|
15
22
|
|
|
16
|
-
|
|
17
|
-
|
|
23
|
+
Resolve the remaining task argument or the in-context task. It should already have a feature branch from a previous execute.
|
|
24
|
+
|
|
25
|
+
## 2A. Local workflow (default)
|
|
26
|
+
|
|
27
|
+
### Locate the worktree
|
|
28
|
+
|
|
29
|
+
Find the existing task worktree and branch with `git worktree list`, matching by task code. The worktree must already exist; do not create a new branch. If none exists, stop and ask. Merge the latest source branch into the feature branch first to avoid divergence.
|
|
30
|
+
|
|
31
|
+
### Rework
|
|
32
|
+
|
|
33
|
+
Make the requested fix in the worktree with the host's read/search/edit tools, or use a builder subagent with that worktree as its working directory. Keep the change surgical and correct the root cause rather than symptoms. Update subtasks through MCP.
|
|
34
|
+
|
|
35
|
+
Before editing UI pages, components, app shell, forms, or styling, follow `/xevy:xevy-design` and the project's `./.xevy/design.md`.
|
|
36
|
+
|
|
37
|
+
### Review, push, and hand off
|
|
38
|
+
|
|
39
|
+
- Run the full project checks. Verify the issue is fixed without regressions and check every “must NOT” constraint. When supported, dispatch a **reviewer** for an independent PASS/PARTIAL/FAIL with file:line evidence; otherwise perform a separate review pass. Fix every finding and re-run until green.
|
|
40
|
+
- Commit and push the feature branch, refresh the PR, and give the user its link. Do not merge automatically.
|
|
41
|
+
- Do not redeploy Preview automatically. Preview is an explicit user action via `/xevy:deploy preview`.
|
|
42
|
+
- Ask whether to merge with `/xevy:merge`; do not merge on your own.
|
|
43
|
+
|
|
44
|
+
## 2B. Cloud workflow (`--cloud`)
|
|
45
|
+
|
|
46
|
+
### Run the server action
|
|
47
|
+
|
|
48
|
+
- Call `mcp__xevy__start_ai_action({ taskId, action: "fix", stream: true })`; always pass `stream: true`. Report live progress as it arrives. Do not use fire-and-forget or sleep/manual polling loops.
|
|
49
|
+
- Only if the streamed call returns before a terminal status because of a genuine disconnect, resume with `mcp__xevy__get_ai_execution` (use `list_ai_executions` if needed).
|
|
50
|
+
- On failure, surface the output and offer to retry or rerun `/xevy:fix` without `--cloud`.
|
|
51
|
+
|
|
52
|
+
### Review and correct
|
|
18
53
|
|
|
19
|
-
|
|
20
|
-
-
|
|
21
|
-
-
|
|
22
|
-
-
|
|
23
|
-
-
|
|
54
|
+
- Fetch origin and diff the task's feature branch. Verify the fix resolves the reported issue and introduces no regression; trace it to the failing requirement or QA finding.
|
|
55
|
+
- Run type-check, lint, and tests. If the result remains broken or incomplete, fix it and commit/push to the feature branch, never a protected branch. When useful, dispatch a **reviewer** for an independent pass.
|
|
56
|
+
- Before correcting UI code, follow `/xevy:xevy-design` and the project's `./.xevy/design.md`.
|
|
57
|
+
- Re-run until green and report PASS/PARTIAL/FAIL with evidence and corrections made.
|
|
58
|
+
- Do not redeploy Preview automatically. Preview is an explicit user action via `/xevy:deploy preview`.
|
|
24
59
|
|
|
25
|
-
|
|
26
|
-
- `mcp__xevy__deploy_preview({ taskId, branch })`; report the URL (poll `get_deploy_status`). Non-blocking.
|
|
60
|
+
Report the refreshed PR and verification result.
|
|
@@ -1,31 +1,55 @@
|
|
|
1
1
|
---
|
|
2
2
|
name: generate-image
|
|
3
|
-
description: Generate an image from a text prompt and
|
|
4
|
-
argument-hint: "[prompt describing the image] [--model <id>] [--task <task-code>]"
|
|
5
|
-
allowed-tools: "mcp__xevy__generate_image mcp__xevy__find_task mcp__xevy__get_current_user"
|
|
3
|
+
description: Generate an image from a text prompt and save it in the current Xevy project's Gallery. Use when the user asks to generate an image, logo, mockup, illustration, or other visual asset. Prefer the agent host's built-in image generation feature; use Xevy image generation only when the user explicitly requests it or when no built-in image generation feature is available.
|
|
6
4
|
---
|
|
7
5
|
|
|
8
|
-
#
|
|
6
|
+
# Generate an image
|
|
9
7
|
|
|
10
|
-
Turn
|
|
8
|
+
Turn the user's prompt into an image with the best generation feature available in the current agent host, then save the result in the current Xevy project's Gallery.
|
|
11
9
|
|
|
12
|
-
## 1.
|
|
13
|
-
- Resolve `workspaceIdentifier` + `projectIdentifier` from `.xevy/project.json` when available; otherwise ask the user (or use `list_workspaces` / `list_projects`).
|
|
14
|
-
- Generation requires **write access** to the project. If the user is a guest/read-only member the tool returns 403 — relay that plainly.
|
|
10
|
+
## 1. Choose the generation path
|
|
15
11
|
|
|
16
|
-
|
|
17
|
-
- Use the user's description as the `prompt`. Keep it faithful to what they asked; don't silently restyle.
|
|
18
|
-
- Optional inputs:
|
|
19
|
-
- `model` — an OpenRouter image model id. Omit to use the project default (`google/gemini-3-pro-image-preview`).
|
|
20
|
-
- `size` — a size hint like `1024x1024` (recorded with the asset).
|
|
21
|
-
- `fileName` — a friendly file name.
|
|
22
|
-
- `taskId` — when the image relates to a specific task, pass its UUID so the Gallery can link the asset back to that task. If the user references a task **code** (e.g. VI02-10), resolve it to a UUID with `find_task` first.
|
|
12
|
+
Use this order:
|
|
23
13
|
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
-
|
|
14
|
+
1. If the user explicitly asks for Xevy image generation or a Xevy/OpenRouter model, use the **Xevy path**.
|
|
15
|
+
2. Otherwise, if the agent host provides a built-in image generation feature, use the **built-in path**.
|
|
16
|
+
3. If no built-in image generation feature is available, use the **Xevy path** as the fallback.
|
|
27
17
|
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
18
|
+
Use Xevy for Gallery storage regardless of which feature generates the image. Do not use Xevy's `generate_image` merely because the repository is linked to a Xevy project. If a built-in generation attempt fails, report that failure and ask before switching to Xevy's paid provider unless the user already requested Xevy. If neither built-in generation nor Xevy's `generate_image` tool is available, explain that no image generator is available and stop.
|
|
19
|
+
|
|
20
|
+
## 2. Resolve Xevy context
|
|
21
|
+
|
|
22
|
+
- Resolve `workspaceIdentifier` and `projectIdentifier` from `.xevy/project.json` when available; otherwise ask the user or use Xevy's workspace and project discovery tools.
|
|
23
|
+
- Confirm the user has project write access before generating. Relay a 403 response plainly.
|
|
24
|
+
- Resolve an optional referenced task code such as `VI02-10` to its UUID with `find_task` so the Gallery asset can link back to the task.
|
|
25
|
+
- Stop before generation if the project cannot be resolved or the selected storage tool is unavailable. The completed request must include a Gallery attachment.
|
|
26
|
+
|
|
27
|
+
## 3. Build the prompt
|
|
28
|
+
|
|
29
|
+
- Keep the prompt faithful to the user's request; do not silently change the subject, style, composition, text, or brand direction.
|
|
30
|
+
- Preserve exact text verbatim when the image must contain copy.
|
|
31
|
+
- Include supplied reference images when the selected generation feature supports them.
|
|
32
|
+
|
|
33
|
+
## 4. Built-in path (default)
|
|
34
|
+
|
|
35
|
+
- Use the agent host's built-in image generation feature and follow its native tool instructions.
|
|
36
|
+
- Pass the user's image description and any supported reference images directly to that feature.
|
|
37
|
+
- After generation, call Xevy's `create_attachment` to save the output in the Gallery:
|
|
38
|
+
- Prefer `sourceUrl` when the built-in feature returns a public `http(s)` image URL.
|
|
39
|
+
- Pass a returned data URL directly as `dataBase64`. For a local file, encode its bytes as base64 and pass `dataBase64`; do not pass a local path as `sourceUrl`.
|
|
40
|
+
- Pass `mimeType`, a friendly `fileName`, the prompt as `description`, optional `taskId`, and `public: true`.
|
|
41
|
+
- Provide exactly one of `sourceUrl` or `dataBase64`; inline data must be no larger than 25 MB.
|
|
42
|
+
- Report the URL and file name returned by `create_attachment`, and state that the image is available in the project Gallery.
|
|
43
|
+
- If attachment creation fails, report that the image was generated but not saved to the Gallery. Do not claim the request completed successfully.
|
|
44
|
+
|
|
45
|
+
## 5. Xevy path (explicit or fallback)
|
|
46
|
+
|
|
47
|
+
1. Call Xevy's `generate_image` tool with:
|
|
48
|
+
- `workspaceIdentifier`
|
|
49
|
+
- `projectIdentifier`
|
|
50
|
+
- `prompt`
|
|
51
|
+
- optional `model`, `size`, and `fileName`; `size` accepts `512`, `1K`, `2K`, `4K`, or explicit pixels such as `1024x1024`
|
|
52
|
+
- optional resolved `taskId`
|
|
53
|
+
2. Report the returned clickable URL and file name, and state that the image is available in the project Gallery.
|
|
54
|
+
|
|
55
|
+
`generate_image` stores the result in the Gallery and returns `{ attachmentId, url, fileName, mimeType, sizeBytes, prompt, model }`. Xevy generation is a paid provider call: generate once per request and do not retry after success. Never print API keys or environment values. On failure, surface the tool's error without inventing a cause.
|
|
@@ -16,7 +16,7 @@ allowed-tools: "Read Grep Bash Write Delete mcp__xevy__connector_list mcp__xevy_
|
|
|
16
16
|
|
|
17
17
|
# /xevy:investigate — diagnose before fixing
|
|
18
18
|
|
|
19
|
-
**Investigate first. Do not fix blindly.** Gather evidence with a small, disposable script, report findings, then let the user decide whether to fix (
|
|
19
|
+
**Investigate first. Do not fix blindly.** Gather evidence with a small, disposable script, report findings, then let the user decide whether to fix (for example via `/xevy:fix`, which runs locally by default).
|
|
20
20
|
|
|
21
21
|
## When to use
|
|
22
22
|
|
package/skills/merge/SKILL.md
CHANGED
|
@@ -1,24 +1,64 @@
|
|
|
1
1
|
---
|
|
2
2
|
name: merge
|
|
3
|
-
description: Merge a task
|
|
4
|
-
argument-hint: "[task]"
|
|
3
|
+
description: Merge a task branch locally in the current coding-agent session by default — merge it into the current branch without pushing, verify, and review. Pass --cloud to have the Xevy server agent land the branch into the remote base/default branch, then review the result.
|
|
4
|
+
argument-hint: "[task] [--cloud]"
|
|
5
5
|
disable-model-invocation: true
|
|
6
|
-
allowed-tools: "Read Grep Bash mcp__xevy__find_task mcp__xevy__start_ai_action mcp__xevy__get_ai_execution mcp__xevy__list_ai_executions mcp__xevy__deploy_main mcp__xevy__get_deploy_status"
|
|
6
|
+
allowed-tools: "Read Grep Edit Bash mcp__xevy__find_task mcp__xevy__start_ai_action mcp__xevy__get_ai_execution mcp__xevy__list_ai_executions mcp__xevy__deploy_main mcp__xevy__get_deploy_status"
|
|
7
7
|
---
|
|
8
8
|
|
|
9
|
-
# /xevy:merge — merge in the cloud
|
|
9
|
+
# /xevy:merge — merge locally or in the cloud
|
|
10
10
|
|
|
11
|
-
|
|
11
|
+
Local-only merge is the default. Pass the exact standalone `--cloud` flag to have the Xevy server agent land the task branch into the remote base/default branch. These modes have materially different push semantics, so follow only the selected workflow.
|
|
12
|
+
|
|
13
|
+
## 0. Choose the engine
|
|
14
|
+
|
|
15
|
+
- Parse `$ARGUMENTS` for the exact standalone `--cloud` token and remove that token before resolving the task. Do not treat similar text such as `--cloudy`, `cloud`, or `--cloud=true` as the flag.
|
|
16
|
+
- Without `--cloud`, follow the **Local workflow** and do not call `start_ai_action`. The missing flag is an explicit instruction to stay local: for the whole run, `mcp__xevy__start_ai_action`, `mcp__xevy__get_ai_execution`, and `mcp__xevy__list_ai_executions` are forbidden, and so is any other way of handing the work to the Xevy server agent.
|
|
17
|
+
- Never infer the cloud engine from context. Task status, an earlier cloud run, an open pull request, an existing execution record, an idle local worktree, urgency, or a local step that turns out to be slow or hard are **not** consent. Only the literal flag selects the Cloud workflow.
|
|
18
|
+
- If the Local workflow cannot be completed, stop and report exactly what is blocking it, then let the user decide whether to rerun with `--cloud`. Never switch engines mid-run and never run both.
|
|
19
|
+
- With `--cloud`, follow the **Cloud workflow** and do not duplicate the work locally beyond the review-and-correct step it defines.
|
|
12
20
|
|
|
13
21
|
## 1. Resolve
|
|
14
|
-
Resolve the task (`$ARGUMENTS` / context).
|
|
15
22
|
|
|
16
|
-
|
|
17
|
-
|
|
23
|
+
Resolve the remaining task argument or the in-context task and its canonical feature branch.
|
|
24
|
+
|
|
25
|
+
## 2A. Local workflow (default)
|
|
26
|
+
|
|
27
|
+
### Merge locally
|
|
28
|
+
|
|
29
|
+
Merge the task branch into the current checked-out branch in the current worktree. Fetch and merge from remote if the task branch exists only there. If conflicts occur, resolve them directly, stage the resolutions, and complete the merge commit.
|
|
30
|
+
|
|
31
|
+
### Review and correct
|
|
32
|
+
|
|
33
|
+
Run verification for the merged scope: inspect `git status`, then run the project's test, lint, and build checks. Report clear PASS/FAIL plus every conflict file resolved. Fix failures before finishing.
|
|
34
|
+
|
|
35
|
+
### Local safety rules
|
|
36
|
+
|
|
37
|
+
- The merge stays in this working copy. Do not `git push` anything — not the base branch, not the feature branch, not tags.
|
|
38
|
+
- Do not open, update, or merge a pull request, and do not call the GitHub merge API, `gh pr merge`, or `gh pr create`. Landing the branch on the remote is the Cloud workflow's job and requires `--cloud`.
|
|
39
|
+
- Do not change task status; in particular, do not move the task to `done`.
|
|
40
|
+
- Do not deploy main, and do not "land it through a PR first" to make the merge visible remotely. If the user wants main updated, say the merge is local and unpushed, and let them decide what to do next.
|
|
41
|
+
- The user pushes manually from the main worktree.
|
|
42
|
+
- Keep the task worktree for iteration; do not delete it.
|
|
43
|
+
|
|
44
|
+
## 2B. Cloud workflow (`--cloud`)
|
|
45
|
+
|
|
46
|
+
### Run the server action
|
|
47
|
+
|
|
48
|
+
- Call `mcp__xevy__start_ai_action({ taskId, action: "merge", stream: true })`; always pass `stream: true`. Report live progress, conflicts, and verification results as they arrive. Do not use fire-and-forget or sleep/manual polling loops.
|
|
49
|
+
- Only if the streamed call returns before a terminal status because of a genuine disconnect, resume with `mcp__xevy__get_ai_execution` (use `list_ai_executions` if needed).
|
|
50
|
+
- On failure, surface the output and offer to retry or rerun `/xevy:merge` without `--cloud` for a local-only merge.
|
|
51
|
+
|
|
52
|
+
The server agent verifies the open-subtasks gate, syncs the base into the feature branch, then lands the feature into the remote base/default branch through the GitHub merge API when possible or a local merge and push otherwise. The action does not change task status.
|
|
53
|
+
|
|
54
|
+
### Review and correct
|
|
55
|
+
|
|
56
|
+
- Fetch origin and inspect the merged branch. Confirm the merge is clean, the base was integrated, and build/tests pass.
|
|
57
|
+
- If conflicts remain or tests fail, fix them on the feature branch; never push a protected branch directly. Re-verify before finishing.
|
|
58
|
+
- Report PASS/PARTIAL/FAIL with evidence. Merge mode must not move the task to `done`.
|
|
59
|
+
|
|
60
|
+
## 3. Main deploy — cloud workflow only (optional, policy-aware)
|
|
18
61
|
|
|
19
|
-
|
|
20
|
-
- `git fetch origin` and inspect the merged branch. Confirm the merge is clean, the base was integrated, and the build/tests still pass. If conflicts were left or tests fail, **fix them** on the feature branch (never push a protected branch directly) and re-verify.
|
|
21
|
-
- Report PASS/PARTIAL/FAIL with evidence. Merge mode must NOT move the task to done.
|
|
62
|
+
This step does not apply to the Local workflow. After a local merge, report that the merge is local and unpushed, so main cannot reflect it, and stop there.
|
|
22
63
|
|
|
23
|
-
|
|
24
|
-
- If the user wants main updated, `mcp__xevy__deploy_main` deploys the project's REMOTE default branch. NEVER push protected branches (master/main/develop/staging) to make main reflect local work — land via PR first; warn that main shows the remote/PR-merged state. Report the main URL.
|
|
64
|
+
In the Cloud workflow, if the user wants main updated, `mcp__xevy__deploy_main` deploys the project's remote default branch. Never push protected branches (`master`, `main`, `develop`, `staging`) to make main reflect local work, and warn that main shows the remote/PR-merged state. Report the main URL.
|
|
@@ -1,21 +1,57 @@
|
|
|
1
1
|
---
|
|
2
2
|
name: move-to-qa
|
|
3
|
-
description: Move a task to QA in the
|
|
4
|
-
argument-hint: "[task]"
|
|
3
|
+
description: Move a task to QA locally in the current coding-agent session by default — write or update non-technical QA Notes, set for_qa, and review. Pass --cloud to delegate the QA handoff to the Xevy server agent, then review and correct its result.
|
|
4
|
+
argument-hint: "[task] [--cloud]"
|
|
5
5
|
disable-model-invocation: true
|
|
6
|
-
allowed-tools: "Read Bash mcp__xevy__find_task mcp__xevy__list_task_notes mcp__xevy__get_task_note mcp__xevy__start_ai_action mcp__xevy__get_ai_execution mcp__xevy__list_ai_executions"
|
|
6
|
+
allowed-tools: "Read Grep Bash mcp__xevy__find_task mcp__xevy__list_task_notes mcp__xevy__get_task_note mcp__xevy__create_task_note mcp__xevy__update_task_note mcp__xevy__update_task_status mcp__xevy__start_ai_action mcp__xevy__get_ai_execution mcp__xevy__list_ai_executions"
|
|
7
7
|
---
|
|
8
8
|
|
|
9
|
-
# /xevy:move-to-qa — move to QA in the cloud
|
|
9
|
+
# /xevy:move-to-qa — move to QA locally or in the cloud
|
|
10
10
|
|
|
11
|
-
|
|
11
|
+
Local QA handoff is the default. Pass the exact standalone `--cloud` flag to delegate it to the Xevy server agent.
|
|
12
|
+
|
|
13
|
+
## 0. Choose the engine
|
|
14
|
+
|
|
15
|
+
- Parse `$ARGUMENTS` for the exact standalone `--cloud` token and remove that token before resolving the task. Do not treat similar text such as `--cloudy`, `cloud`, or `--cloud=true` as the flag.
|
|
16
|
+
- Without `--cloud`, follow the **Local workflow** and do not call `start_ai_action`. The missing flag is an explicit instruction to stay local: for the whole run, `mcp__xevy__start_ai_action`, `mcp__xevy__get_ai_execution`, and `mcp__xevy__list_ai_executions` are forbidden, and so is any other way of handing the work to the Xevy server agent.
|
|
17
|
+
- Never infer the cloud engine from context. Task status, an earlier cloud run, an open pull request, an existing execution record, an idle local worktree, urgency, or a local step that turns out to be slow or hard are **not** consent. Only the literal flag selects the Cloud workflow.
|
|
18
|
+
- If the Local workflow cannot be completed, stop and report exactly what is blocking it, then let the user decide whether to rerun with `--cloud`. Never switch engines mid-run and never run both.
|
|
19
|
+
- With `--cloud`, follow the **Cloud workflow** and do not duplicate the work locally beyond the review-and-correct step it defines.
|
|
12
20
|
|
|
13
21
|
## 1. Resolve
|
|
14
|
-
Resolve the task (`$ARGUMENTS` / context).
|
|
15
22
|
|
|
16
|
-
|
|
17
|
-
|
|
23
|
+
Resolve the remaining task argument or the in-context task. Read the implementation and what changed.
|
|
24
|
+
|
|
25
|
+
## 2A. Local workflow (default)
|
|
26
|
+
|
|
27
|
+
### Write QA Notes
|
|
28
|
+
|
|
29
|
+
Create or update a note titled `QA Re-Testing Guide` with `create_task_note` or `update_task_note`. Keep it non-technical and UI-verifiable, with these sections in order:
|
|
30
|
+
|
|
31
|
+
1. Pre-Test Preconditions — deployment, context, and account readiness.
|
|
32
|
+
2. Reproduction Steps — a step table with expected vs actual and pass/fail.
|
|
33
|
+
3. Expected vs Actual Behaviour — plus an edge-case checklist.
|
|
34
|
+
4. Validation Checks — functional, UI/UX, data/state, and integration.
|
|
35
|
+
5. Screenshots/Logs/Evidence — what to capture and how.
|
|
36
|
+
6. Final Verdict — Pass, Fail, or Partial plus follow-ups.
|
|
37
|
+
|
|
38
|
+
### Set status and review
|
|
39
|
+
|
|
40
|
+
Set the task to `for_qa` with `update_task_status`; never move it to `done`. Re-read the notes and confirm a non-technical QA can follow every step in the UI and that expected results are concrete. Fix gaps before finishing. Report the task URL and a short summary.
|
|
41
|
+
|
|
42
|
+
## 2B. Cloud workflow (`--cloud`)
|
|
43
|
+
|
|
44
|
+
### Run the server action
|
|
45
|
+
|
|
46
|
+
- Call `mcp__xevy__start_ai_action({ taskId, action: "move-to-qa", stream: true })`; always pass `stream: true`. Report live progress as it arrives. Do not use fire-and-forget or sleep/manual polling loops.
|
|
47
|
+
- Only if the streamed call returns before a terminal status because of a genuine disconnect, resume with `mcp__xevy__get_ai_execution` (use `list_ai_executions` if needed).
|
|
48
|
+
- On failure, surface the output and offer to retry or rerun `/xevy:move-to-qa` without `--cloud`.
|
|
49
|
+
|
|
50
|
+
### Review and correct
|
|
51
|
+
|
|
52
|
+
- Read the QA Notes with `list_task_notes` then `get_task_note`.
|
|
53
|
+
- Verify they are non-technical and UI-verifiable, covering preconditions, step-by-step reproduction with expected versus actual results, validation checks, evidence to capture, and a final verdict.
|
|
54
|
+
- If the notes are thin or too technical, repair them with `update_task_note` using the same structure as the Local workflow.
|
|
55
|
+
- Confirm task status is `for_qa`, never `done`.
|
|
18
56
|
|
|
19
|
-
|
|
20
|
-
- Read the QA Notes (`list_task_notes` → `get_task_note`). Verify they are non-technical and UI-verifiable, with: pre-test preconditions, step-by-step reproduction (expected vs actual), validation checks, evidence to capture, and a final verdict section.
|
|
21
|
-
- If thin or technical, **fix** them (rewrite via the local variant or `update_task_note`). Confirm status is `for_qa` (not `done`). Report what you corrected and the task URL.
|
|
57
|
+
Report what you corrected and the task URL.
|
package/skills/plan/SKILL.md
CHANGED
|
@@ -1,25 +1,66 @@
|
|
|
1
1
|
---
|
|
2
2
|
name: plan
|
|
3
|
-
description: Plan a task in the
|
|
4
|
-
argument-hint: "[task]"
|
|
3
|
+
description: Plan a task locally in the current coding-agent session by default — inspect the codebase, write the plan spec and ordered subtasks, then review them. Pass --cloud to delegate planning to the Xevy server agent, then review and correct its result.
|
|
4
|
+
argument-hint: "[task] [--cloud]"
|
|
5
5
|
disable-model-invocation: true
|
|
6
|
-
allowed-tools: "Read Grep Bash mcp__xevy__find_task mcp__xevy__list_specs mcp__xevy__get_spec mcp__xevy__list_subtasks mcp__xevy__start_ai_action mcp__xevy__get_ai_execution mcp__xevy__list_ai_executions"
|
|
6
|
+
allowed-tools: "Read Grep Bash Agent mcp__xevy__find_task mcp__xevy__create_spec mcp__xevy__update_spec mcp__xevy__list_specs mcp__xevy__get_spec mcp__xevy__create_subtask mcp__xevy__update_subtask mcp__xevy__list_subtasks mcp__xevy__list_task_decisions mcp__xevy__create_decision mcp__xevy__answer_decision mcp__xevy__get_process_owners mcp__xevy__update_task_status mcp__xevy__start_ai_action mcp__xevy__get_ai_execution mcp__xevy__list_ai_executions"
|
|
7
7
|
---
|
|
8
8
|
|
|
9
|
-
# /xevy:plan — plan in the cloud
|
|
9
|
+
# /xevy:plan — plan locally or in the cloud
|
|
10
10
|
|
|
11
|
-
|
|
11
|
+
Local planning is the default. Pass the exact standalone `--cloud` flag to delegate planning to the Xevy server agent.
|
|
12
|
+
|
|
13
|
+
## 0. Choose the engine
|
|
14
|
+
|
|
15
|
+
- Parse `$ARGUMENTS` for the exact standalone `--cloud` token and remove that token before resolving the task. Do not treat similar text such as `--cloudy`, `cloud`, or `--cloud=true` as the flag.
|
|
16
|
+
- Without `--cloud`, follow the **Local workflow** and do not call `start_ai_action`. The missing flag is an explicit instruction to stay local: for the whole run, `mcp__xevy__start_ai_action`, `mcp__xevy__get_ai_execution`, and `mcp__xevy__list_ai_executions` are forbidden, and so is any other way of handing the work to the Xevy server agent.
|
|
17
|
+
- Never infer the cloud engine from context. Task status, an earlier cloud run, an open pull request, an existing execution record, an idle local worktree, urgency, or a local step that turns out to be slow or hard are **not** consent. Only the literal flag selects the Cloud workflow.
|
|
18
|
+
- If the Local workflow cannot be completed, stop and report exactly what is blocking it, then let the user decide whether to rerun with `--cloud`. Never switch engines mid-run and never run both.
|
|
19
|
+
- With `--cloud`, follow the **Cloud workflow** and do not duplicate the work locally beyond the review-and-correct step it defines.
|
|
12
20
|
|
|
13
21
|
## 1. Resolve the task
|
|
14
|
-
Resolve from `$ARGUMENTS` or context. The task should be analyzed first (a `## Analysis` section). If not, suggest `/xevy:analyze` and stop.
|
|
15
22
|
|
|
16
|
-
|
|
17
|
-
|
|
23
|
+
Resolve the remaining task argument or the in-context task. It should already have a `## Analysis` section. If it does not, suggest `/xevy:analyze` and stop.
|
|
24
|
+
|
|
25
|
+
## 2A. Local workflow (default)
|
|
26
|
+
|
|
27
|
+
### Decisions gate and recon
|
|
28
|
+
|
|
29
|
+
Call `mcp__xevy__list_task_decisions`. If any decision is **open**, resolve it first: present it through the host's user-question mechanism, record the answer with `mcp__xevy__answer_decision`, and reflect it in the plan. Open decisions block AI work, so never guess or bypass them.
|
|
30
|
+
|
|
31
|
+
When the host supports subagents, dispatch a **scout** for codebase recon covering relevant files, callers/callees, similar patterns, and baseline health. Otherwise perform the same recon in this session.
|
|
32
|
+
|
|
33
|
+
### Write the plan
|
|
34
|
+
|
|
35
|
+
- Create a plan spec with `mcp__xevy__create_spec` using kind `plan`. Include step-by-step changes with file paths and line ranges plus a trace matrix: requirement → files → strategy → test.
|
|
36
|
+
- Create ordered subtasks with `mcp__xevy__create_subtask`. Group work into reviewable end-to-end pieces; keep frontend and backend work for one capability together.
|
|
37
|
+
|
|
38
|
+
### Plan-review
|
|
39
|
+
|
|
40
|
+
When the host supports subagents, dispatch a **plan-reviewer** to cross-check every matrix item against requirements, find orphans and gaps, verify cross-flow risks and “must NOT” constraints, and confirm tests hit the exact branches. Otherwise perform a separate self-review pass. Fold the findings into the spec and subtasks.
|
|
41
|
+
|
|
42
|
+
If planning surfaces a genuine question a human must resolve, record it with `mcp__xevy__create_decision` using preset choices and explanations instead of guessing.
|
|
43
|
+
|
|
44
|
+
### Final check
|
|
45
|
+
|
|
46
|
+
Confirm the final plan is complete and feasible against the actual code and fix every remaining gap. Call `mcp__xevy__list_task_decisions` again and surface any decision that remains open. Do not change task status as a side effect of local planning. Draft is preparation-only; the user explicitly submits it to Ready. When planning is configured Refine work for a Ready task, completion moves it to Planned through the server-owned Process Owner flow. Do not start execution.
|
|
47
|
+
|
|
48
|
+
Report a PASS/PARTIAL verdict, the matrix summary, open decisions, resulting status, and task URL.
|
|
49
|
+
|
|
50
|
+
## 2B. Cloud workflow (`--cloud`)
|
|
51
|
+
|
|
52
|
+
### Run the server action
|
|
53
|
+
|
|
54
|
+
- Call `mcp__xevy__start_ai_action({ taskId, action: "plan", stream: true })`; always pass `stream: true`. Report live progress as it arrives. Do not use fire-and-forget or sleep/manual polling loops.
|
|
55
|
+
- Only if the streamed call returns before a terminal status because of a genuine disconnect, resume with `mcp__xevy__get_ai_execution` (use `list_ai_executions` if needed).
|
|
56
|
+
- On failure, surface the output and offer to retry or rerun `/xevy:plan` without `--cloud`.
|
|
57
|
+
|
|
58
|
+
### Review and correct
|
|
18
59
|
|
|
19
|
-
## 3. Review & correct (MANDATORY — act as plan-reviewer)
|
|
20
60
|
- Read the produced plan spec (`list_specs` → `get_spec`) and subtasks (`list_subtasks`).
|
|
21
|
-
- Build a
|
|
22
|
-
- Check cross-flow risks
|
|
23
|
-
-
|
|
24
|
-
- Do
|
|
25
|
-
|
|
61
|
+
- Build a trace matrix from every task/Analysis requirement to a subtask or plan step. Flag orphaned requirements and unjustified steps. Inspect the code with Read/Grep to confirm referenced files and approaches are real and feasible.
|
|
62
|
+
- Check cross-flow risks such as guards, context rehydration, effects, and async side effects. Every “must NOT” constraint needs explicit verification.
|
|
63
|
+
- Fix gaps by editing the spec or adding/reordering subtasks through MCP. Re-review until the matrix has no orphans.
|
|
64
|
+
- Do not change task status or start execution yourself. The server applies Process Owner automation after a successful run.
|
|
65
|
+
|
|
66
|
+
Report a PASS/PARTIAL verdict, gaps closed, resulting task status, and task URL.
|
|
@@ -1,30 +0,0 @@
|
|
|
1
|
-
---
|
|
2
|
-
name: analyze-here
|
|
3
|
-
description: Analyze a task locally in the current coding-agent session — inspect the codebase, write the Analysis section + storyPoints via MCP, then self-review. Cloud equivalent is the analyze skill.
|
|
4
|
-
argument-hint: "[task]"
|
|
5
|
-
disable-model-invocation: true
|
|
6
|
-
allowed-tools: "Read Grep Bash mcp__xevy__find_task mcp__xevy__update_task mcp__xevy__list_specs mcp__xevy__list_subtasks mcp__xevy__create_task_note mcp__xevy__list_task_decisions mcp__xevy__create_decision mcp__xevy__answer_decision"
|
|
7
|
-
---
|
|
8
|
-
|
|
9
|
-
# /xevy:analyze-here — analyze locally (then review)
|
|
10
|
-
|
|
11
|
-
Run the analysis yourself in this session (no server agent). Mirror the Xevy analyze workflow.
|
|
12
|
-
|
|
13
|
-
## 1. Resolve the task
|
|
14
|
-
Resolve from `$ARGUMENTS` or context (`mcp__xevy__find_task` / `find_task`). Read existing specs, subtasks, and notes.
|
|
15
|
-
|
|
16
|
-
## 1b. Decisions gate (BEFORE the work)
|
|
17
|
-
Call `mcp__xevy__list_task_decisions`. If any decision is **open**, resolve them first — open decisions block AI actions. Present each open question through the host's user-question mechanism (using its preset choices + explanations), record the answer with `mcp__xevy__answer_decision`, and fold the answers into the analysis. Never guess or bypass an open decision.
|
|
18
|
-
|
|
19
|
-
## 2. Inspect the codebase
|
|
20
|
-
Read the relevant files (callers, callees, similar patterns). Identify whether the task involves UI changes; if so, study existing UI patterns and record a `UI/UX Flow` note (`create_task_note`). Base decisions on existing patterns — don't ask about every detail.
|
|
21
|
-
|
|
22
|
-
## 3. Write the Analysis
|
|
23
|
-
Use `mcp__xevy__update_task` to append a `## Analysis` section (do NOT replace the user's original request):
|
|
24
|
-
- **Overview:** plain-language summary, before/after behaviour, user impact, key decisions.
|
|
25
|
-
- **Technical Implementation:** affected files/modules, API/data/UI changes, assumptions, risks, verification approach.
|
|
26
|
-
- Estimate `storyPoints` (1 trivial · 2 small · 3 medium · 5 large · 8 XL · 13 epic) and set it.
|
|
27
|
-
- **Open questions:** for a genuine ambiguity a human must resolve, don't bury it as an assumption — record it with `mcp__xevy__create_decision` (preset choices + explanation, optional follow-up per choice). It will gate the next step until answered. If the user is present, use the host's user-question mechanism and persist the result with `create_decision` + `answer_decision`.
|
|
28
|
-
|
|
29
|
-
## 4. Review & correct (MANDATORY)
|
|
30
|
-
Re-read your Analysis against the actual code: is every claim accurate, are affected files real, are risks/ACs concrete? Fix any gap or inaccuracy before finishing. Then call `mcp__xevy__list_task_decisions` once more (post-check): if any decision is still open, surface it to the user. Report a PASS/PARTIAL verdict, what you corrected, any open decisions, and the task URL. Do not push the user to plan/execute next.
|
|
@@ -1,36 +0,0 @@
|
|
|
1
|
-
---
|
|
2
|
-
name: execute-here
|
|
3
|
-
description: Execute a task locally in the current coding-agent session — worktree, implement against the plan, run tests, commit, push, open a PR, deploy a preview, then review/correct. Cloud equivalent is the execute skill.
|
|
4
|
-
argument-hint: "[task]"
|
|
5
|
-
disable-model-invocation: true
|
|
6
|
-
allowed-tools: "Read Grep Edit Write Bash Agent mcp__xevy__find_task mcp__xevy__update_task mcp__xevy__update_task_status mcp__xevy__list_specs mcp__xevy__list_subtasks mcp__xevy__update_subtask mcp__xevy__list_sprints mcp__xevy__assign_task_to_sprint mcp__xevy__deploy_preview mcp__xevy__get_deploy_status mcp__xevy__list_task_decisions mcp__xevy__create_decision mcp__xevy__answer_decision set_session_task_lock"
|
|
7
|
-
---
|
|
8
|
-
|
|
9
|
-
# /xevy:execute-here — implement locally (then review + deploy)
|
|
10
|
-
|
|
11
|
-
You are the engine: implement the task in this session, following the Xevy worktree + git protocol.
|
|
12
|
-
|
|
13
|
-
## 1. Resolve + gates
|
|
14
|
-
- Resolve the task (`$ARGUMENTS` / context). Read its `## Analysis`, plan spec, and subtasks. If none and non-trivial, suggest `/xevy:plan-here` or ask whether to plan-and-execute or execute directly.
|
|
15
|
-
- **Decisions gate (BEFORE implementing):** call `mcp__xevy__list_task_decisions`. If any decision is **open**, resolve it first — open decisions block execution. Present each through the host's user-question mechanism, record with `mcp__xevy__answer_decision`, and fold the answer into the work (if a relevant subtask is already done, the answer may warrant a new subtask). Never guess or bypass.
|
|
16
|
-
- Sprint gate: same as cloud — if an active sprint exists and the task isn't on it, require `## Analysis` + `storyPoints` > 0 then `assign_task_to_sprint`, else stop and ask.
|
|
17
|
-
|
|
18
|
-
## 2. Worktree protocol
|
|
19
|
-
- Record the current branch + dir. Derive a canonical branch `xevy/<TASK-ID>-<slug>` (task id = task code, or first 8 chars of task UUID; reuse if one already exists for this task — never create a second branch per task).
|
|
20
|
-
- Create/attach a git worktree in a sibling dir and `cd` into it; if resuming, first merge the latest source branch (e.g. `git merge origin/main`). Do ALL work in the worktree.
|
|
21
|
-
- In Pi, call `set_session_task_lock(taskCode, taskId, taskTitle, worktreePath, branch)` immediately after attaching the worktree, using its absolute `git rev-parse --show-toplevel` path. If that tool is unavailable, continue—the worktree rules still apply.
|
|
22
|
-
- NEVER commit/push on a protected branch (master/main/develop/staging) — only on `xevy/*` task branches.
|
|
23
|
-
|
|
24
|
-
## 3. Implement
|
|
25
|
-
- Move the task to `in_progress` (`update_task_status`) when implementation begins — mirrors the cloud `execute`, which flips to `in_progress` at start (and to `for_review` on success).
|
|
26
|
-
- Work the subtasks in order with the host's read/search/edit tools. When supported and useful, dispatch builder/frontend subagents with the worktree as their working directory. Keep changes surgical, match existing style, and update subtask status via MCP as you go.
|
|
27
|
-
- **Frontend/UI changes:** before editing any UI (pages, components, app shell, forms, styling), follow the `/xevy:xevy-design` skill so the change matches the project design system (`./.xevy/design.md`).
|
|
28
|
-
- If you hit a genuine ambiguity a human must resolve mid-implementation, raise it with `mcp__xevy__create_decision` (preset choices) rather than guessing — or, if the user is present, use the host's user-question mechanism and persist with `create_decision` + `answer_decision`. Open decisions block further AI steps until answered.
|
|
29
|
-
- Validate after each step (type-check → lint → targeted tests).
|
|
30
|
-
|
|
31
|
-
## 4. Review & correct (MANDATORY)
|
|
32
|
-
- Run the full project checks. Trace every requirement to code and check "must NOT" constraints. When the host supports subagents, dispatch a **reviewer** for an independent PASS/PARTIAL/FAIL with file:line evidence; otherwise perform a separate review pass yourself. Fix everything it flags and re-run until green.
|
|
33
|
-
|
|
34
|
-
## 5. Push, PR, deploy
|
|
35
|
-
- Commit + push the task branch. Open/refresh the PR and ALWAYS give the user the PR/compare link. Do NOT merge automatically.
|
|
36
|
-
- Record the branch on the task (`update_task` metadata `aiPullRequest.branch`) so deploys resolve it, then `mcp__xevy__deploy_preview({ taskId, branch })`; report the URL. Move status to `for_review` (`update_task_status`).
|
package/skills/fix-here/SKILL.md
DELETED
|
@@ -1,23 +0,0 @@
|
|
|
1
|
-
---
|
|
2
|
-
name: fix-here
|
|
3
|
-
description: Apply a fix/rework to a task locally in the current coding-agent session — reuse the task worktree, rework, run tests, push, refresh the PR, redeploy preview, then review. Cloud equivalent is the fix skill.
|
|
4
|
-
argument-hint: "[task]"
|
|
5
|
-
disable-model-invocation: true
|
|
6
|
-
allowed-tools: "Read Grep Edit Write Bash Agent mcp__xevy__find_task mcp__xevy__update_task mcp__xevy__list_subtasks mcp__xevy__update_subtask mcp__xevy__deploy_preview mcp__xevy__get_deploy_status"
|
|
7
|
-
---
|
|
8
|
-
|
|
9
|
-
# /xevy:fix-here — fix locally (then review + redeploy)
|
|
10
|
-
|
|
11
|
-
## 1. Resolve + locate worktree
|
|
12
|
-
Resolve the task (`$ARGUMENTS` / context). Find the EXISTING worktree/branch for it (`git worktree list`, match by task code). The worktree MUST already exist — do not create a new branch; if none, stop and ask. Merge the latest source branch into the feature branch first to avoid divergence.
|
|
13
|
-
|
|
14
|
-
## 2. Rework
|
|
15
|
-
Make the requested fix in the worktree with the host's read/search/edit tools, or use a builder subagent with the worktree as its working directory when the host supports one. Keep it surgical; root-cause the issue rather than patching symptoms. Update subtasks via MCP.
|
|
16
|
-
|
|
17
|
-
## 3. Review & correct (MANDATORY)
|
|
18
|
-
Run the full project checks. Verify the fix resolves the issue with no regressions and check "must NOT" constraints. When supported, dispatch a **reviewer** subagent (PASS/PARTIAL/FAIL + file:line); otherwise perform a separate review pass yourself. Fix anything flagged and re-run until green.
|
|
19
|
-
|
|
20
|
-
**Frontend/UI changes:** before editing any UI (pages, components, app shell, forms, styling), follow the `/xevy:xevy-design` skill so the change matches the project design system (`./.xevy/design.md`).
|
|
21
|
-
|
|
22
|
-
## 4. Push, PR, deploy
|
|
23
|
-
Commit + push the feature branch; refresh the PR and give the user the link. Do NOT merge automatically. Then `mcp__xevy__deploy_preview({ taskId, branch })`; report the URL. Ask whether to merge back via `/xevy:merge` — don't merge on your own.
|
|
@@ -1,22 +0,0 @@
|
|
|
1
|
-
---
|
|
2
|
-
name: merge-here
|
|
3
|
-
description: Merge a task's branch locally in the current coding-agent session — merge the feature branch into the current branch for review (no push), run tests, resolve conflicts, then review. Cloud equivalent is the merge skill.
|
|
4
|
-
argument-hint: "[task]"
|
|
5
|
-
disable-model-invocation: true
|
|
6
|
-
allowed-tools: "Read Grep Edit Bash mcp__xevy__find_task mcp__xevy__deploy_main mcp__xevy__get_deploy_status"
|
|
7
|
-
---
|
|
8
|
-
|
|
9
|
-
# /xevy:merge-here — merge locally (then review)
|
|
10
|
-
|
|
11
|
-
## 1. Resolve + merge
|
|
12
|
-
Resolve the task (`$ARGUMENTS` / context) and its canonical branch. Merge that branch into the CURRENT checked-out branch in the current worktree (fetch + merge from remote if it only exists there). If conflicts occur, resolve them directly (don't abort), stage, and complete the merge commit.
|
|
13
|
-
|
|
14
|
-
## 2. Review & correct (MANDATORY)
|
|
15
|
-
Run verification for the merged scope: `git status`, then the project's test/lint/build checks. Report clear PASS/FAIL plus any conflict files you resolved. Fix failures before finishing.
|
|
16
|
-
|
|
17
|
-
## 3. Rules
|
|
18
|
-
- The merge is LOCAL ONLY — do NOT push, and do NOT change task status (no move to done). The user pushes manually from the main worktree.
|
|
19
|
-
- Keep the task worktree for iteration (don't delete it).
|
|
20
|
-
|
|
21
|
-
## 4. Main deploy (optional, policy-aware)
|
|
22
|
-
If the user wants main updated: NEVER push a protected base (master/main/develop/staging) directly — those need a PR. If the base is protected, call `mcp__xevy__deploy_main` (deploys the REMOTE default branch) and warn it won't include this local merge until the PR lands. Only a non-protected base may be pushed (with explicit approval) before deploying. Report the main URL.
|
|
@@ -1,21 +0,0 @@
|
|
|
1
|
-
---
|
|
2
|
-
name: move-to-qa-here
|
|
3
|
-
description: Move a task to QA locally in the current coding-agent session — write/update non-technical, UI-verifiable QA Notes, set status for_qa, then review. Cloud equivalent is the move-to-qa skill.
|
|
4
|
-
argument-hint: "[task]"
|
|
5
|
-
disable-model-invocation: true
|
|
6
|
-
allowed-tools: "Read Grep Bash mcp__xevy__find_task mcp__xevy__list_task_notes mcp__xevy__create_task_note mcp__xevy__update_task_note mcp__xevy__update_task_status"
|
|
7
|
-
---
|
|
8
|
-
|
|
9
|
-
# /xevy:move-to-qa-here — move to QA locally (then review)
|
|
10
|
-
|
|
11
|
-
## 1. Resolve
|
|
12
|
-
Resolve the task (`$ARGUMENTS` / context). Read the implementation and what changed.
|
|
13
|
-
|
|
14
|
-
## 2. Write QA Notes
|
|
15
|
-
Create or update a note titled `QA Re-Testing Guide` (`create_task_note`/`update_task_note`). Keep it non-technical and UI-verifiable, with these sections in order: (1) Pre-Test Preconditions — deployment/context/account readiness; (2) Reproduction Steps — step table with expected vs actual + pass/fail; (3) Expected vs Actual Behaviour + edge-case checklist; (4) Validation Checks — functional, UI/UX, data/state, integration; (5) Screenshots/Logs/Evidence — what + how to capture; (6) Final Verdict — Pass/Fail/Partial + follow-ups.
|
|
16
|
-
|
|
17
|
-
## 3. Set status
|
|
18
|
-
Set the task status to `for_qa` (`update_task_status`). Do NOT move to `done`.
|
|
19
|
-
|
|
20
|
-
## 4. Review & correct (MANDATORY)
|
|
21
|
-
Re-read the QA Notes: are the steps something a non-technical QA can follow and verify in the UI? Are expected results concrete? Fix gaps before finishing. Report the task URL and a short summary.
|
|
@@ -1,26 +0,0 @@
|
|
|
1
|
-
---
|
|
2
|
-
name: plan-here
|
|
3
|
-
description: Plan a task locally in the current coding-agent session — dispatch scout + plan-reviewer subagents when supported, write the plan spec + ordered subtasks via MCP, then review. Cloud equivalent is the plan skill.
|
|
4
|
-
argument-hint: "[task]"
|
|
5
|
-
disable-model-invocation: true
|
|
6
|
-
allowed-tools: "Read Grep Bash Agent mcp__xevy__find_task mcp__xevy__create_spec mcp__xevy__update_spec mcp__xevy__list_specs mcp__xevy__create_subtask mcp__xevy__list_subtasks mcp__xevy__list_task_decisions mcp__xevy__create_decision mcp__xevy__answer_decision mcp__xevy__get_process_owners mcp__xevy__update_task_status"
|
|
7
|
-
---
|
|
8
|
-
|
|
9
|
-
# /xevy:plan-here — plan locally (then review)
|
|
10
|
-
|
|
11
|
-
Run planning yourself in this session.
|
|
12
|
-
|
|
13
|
-
## 1. Resolve + recon
|
|
14
|
-
Resolve the task (`find_task` by code); it should have a `## Analysis` section (otherwise suggest the `analyze-here` skill). **Decisions gate (BEFORE the work):** call `mcp__xevy__list_task_decisions`; if any decision is **open**, resolve it first (open decisions block AI actions) — present each through the host's user-question mechanism, record with `mcp__xevy__answer_decision`, and reflect it in the plan. When the host supports subagents, dispatch a **scout** for codebase recon — relevant files, callers/callees, similar patterns, baseline health. Otherwise perform the same recon in the current session.
|
|
15
|
-
|
|
16
|
-
## 2. Write the plan
|
|
17
|
-
- Create a plan spec (`mcp__xevy__create_spec`, kind `plan`) with step-by-step changes (file paths + line ranges) and a trace matrix (requirement → files → strategy → test).
|
|
18
|
-
- Create ordered subtasks (`mcp__xevy__create_subtask`) grouping the work into reviewable pieces, each end-to-end (frontend + backend for one feature together).
|
|
19
|
-
|
|
20
|
-
## 3. Plan-review
|
|
21
|
-
When the host supports subagents, dispatch a **plan-reviewer** to cross-check every matrix item vs requirements (no orphans/gaps), verify cross-flow risks and "must NOT" constraints are covered, and confirm tests hit the exact branches. Otherwise perform a separate self-review pass with the same checks. Fold the findings back into the spec/subtasks.
|
|
22
|
-
|
|
23
|
-
When planning surfaces a genuine open question a human must resolve, record it with `mcp__xevy__create_decision` (preset choices + explanation) rather than guessing — it gates execution until answered.
|
|
24
|
-
|
|
25
|
-
## 4. Review & correct (MANDATORY)
|
|
26
|
-
Confirm the final plan is complete and feasible against the actual code; fix any remaining gap before finishing. Post-check: call `mcp__xevy__list_task_decisions` — if any decision is still open, surface it. Do not change task status as a side effect of local planning. Draft is preparation-only; the user explicitly submits it to Ready. When planning is performed as the configured Refine work for a Ready task, completion moves it to Planned through the normal server-owned Process Owner flow. Do not start execution as part of local planning. Report a PASS/PARTIAL verdict, the matrix summary, any open decisions, the resulting status, and the task URL.
|