From 6bd45eb80be2bb3e3c1a16f9108dba29c5a92ccf Mon Sep 17 00:00:00 2001 From: William Thorsen Date: Sun, 17 May 2026 22:09:47 -0700 Subject: [PATCH 1/2] agents|fix: Make skill tool-name references platform-portable Skills installed for Rovo Dev now render tool-name prose with platform-native tool names. The `Task` tool resolves to `invoke_subagent`; references to `WebFetch` are reworded tool-neutrally because Rovo Dev has no native web-fetch counterpart and web access flows through MCP servers or shell tools. --- .../skills/_data/artifact-conventions.md | 24 ++++----- .../skills/_data/ticket-source-resolution.md | 4 +- .../find-orchestration-savings/SKILL.md | 6 +-- .../content/skills/orchestrate/SKILL.md | 52 +++++++++---------- .../orchestrate/modules/review-cycle.md | 38 +++++++------- .../skills/plan-orchestrable-steps/SKILL.md | 6 +-- .../content/skills/refine-plan/SKILL.md | 10 ++-- .../agents/content/subagents/_data/claude.yml | 1 + .../content/subagents/_data/rovodev.yml | 1 + 9 files changed, 72 insertions(+), 70 deletions(-) diff --git a/packages/agents/content/skills/_data/artifact-conventions.md b/packages/agents/content/skills/_data/artifact-conventions.md index 9b4f66cb..a7cde884 100644 --- a/packages/agents/content/skills/_data/artifact-conventions.md +++ b/packages/agents/content/skills/_data/artifact-conventions.md @@ -550,17 +550,17 @@ Each role maps to one of five workflow-function types: ### Artifact entry fields -| Field | Required | Description | -| ----------- | -------- | --------------------------------------------------------------------------------------- | -| `filename` | yes | Artifact filename (without directory path) | -| `role` | yes | Filename role segment (e.g., `reviewer`, `code-reviewer`) | -| `roleType` | yes | Workflow function (one of: `orchestrator`, `analyst`, `planner`, `author`, `reviewer`) | -| `agent` | yes | Task tool `subagent_type` value (e.g., `orchestrated-reviewer`, `aspect-code-reviewer`) | -| `type` | yes | Artifact type (e.g., `review`, `change-summary`) | -| `phase` | yes | Phase that produced this artifact (camelCase, matches `phases` object keys) | -| `createdAt` | yes | ISO 8601 timestamp | -| `iteration` | no | Review iteration number (for `parallelReview` phase) | -| `note` | no | Free-text context about the artifact | +| Field | Required | Description | +| ----------- | -------- | ----------------------------------------------------------------------------------------- | +| `filename` | yes | Artifact filename (without directory path) | +| `role` | yes | Filename role segment (e.g., `reviewer`, `code-reviewer`) | +| `roleType` | yes | Workflow function (one of: `orchestrator`, `analyst`, `planner`, `author`, `reviewer`) | +| `agent` | yes | {tool:Task} `subagent_type` value (e.g., `orchestrated-reviewer`, `aspect-code-reviewer`) | +| `type` | yes | Artifact type (e.g., `review`, `change-summary`) | +| `phase` | yes | Phase that produced this artifact (camelCase, matches `phases` object keys) | +| `createdAt` | yes | ISO 8601 timestamp | +| `iteration` | no | Review iteration number (for `parallelReview` phase) | +| `note` | no | Free-text context about the artifact | ### Phase values @@ -597,7 +597,7 @@ Companion file in the same run directory. Each line is a JSON object (JSONL form ### Event types -All 13 valid event types and their required fields. Fields suffixed with `?` are optional — usage fields (`tokens`, `toolUses`, `durationMs`) are present on newer runs where the orchestrator captures Task result metrics; older runs omit them: +All 13 valid event types and their required fields. Fields suffixed with `?` are optional — usage fields (`tokens`, `toolUses`, `durationMs`) are present on newer runs where the orchestrator captures {tool:Task} result metrics; older runs omit them: | Event type | Key fields | | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | diff --git a/packages/agents/content/skills/_data/ticket-source-resolution.md b/packages/agents/content/skills/_data/ticket-source-resolution.md index 890b8086..2a308830 100644 --- a/packages/agents/content/skills/_data/ticket-source-resolution.md +++ b/packages/agents/content/skills/_data/ticket-source-resolution.md @@ -6,8 +6,8 @@ Resolve a ticket source argument into ticket content and metadata. Skills that a | Input form | Resolution | | ----------------------------------------------------------- | ----------------------------------------------------------------- | -| URL to a known platform (GitHub, Jira, etc.) | Use platform CLI or WebFetch to retrieve issue content | -| Other URL | WebFetch the URL content | +| URL to a known platform (GitHub, Jira, etc.) | Use platform CLI if available; otherwise, fetch the URL content | +| Other URL | Fetch the URL content | | Shorthand reference (`#99`, `issue 99`, `GitHub issue #99`) | Resolve platform (see below), then fetch via platform CLI | | File path | Read the file | | Plain text | Use as-is | diff --git a/packages/agents/content/skills/find-orchestration-savings/SKILL.md b/packages/agents/content/skills/find-orchestration-savings/SKILL.md index a63cd955..0567c0fd 100644 --- a/packages/agents/content/skills/find-orchestration-savings/SKILL.md +++ b/packages/agents/content/skills/find-orchestration-savings/SKILL.md @@ -22,7 +22,7 @@ Analyze a completed orchestrated run to identify cost-saving opportunities while 2. **Verify the run directory** contains `run-log.jsonl` and `run-index.json`. If either is missing, report and exit. -3. **Dispatch the savings-analyzer subagent** via Task tool: +3. **Dispatch the savings-analyzer subagent** via {tool:Task}: - Model: `haiku` - Prompt: Provide the run directory path and the next available sequence number for the artifact filename - The subagent reads the event log, applies the analysis framework, and writes the artifact @@ -31,9 +31,9 @@ Analyze a completed orchestrated run to identify cost-saving opportunities while ## Auto-trigger integration -This skill is also invoked automatically during Phase 5 (summary) of orchestrated runs. The orchestrate engine dispatches the savings-analyzer subagent as a background Task while the orchestrator writes the run-summary inline. When auto-triggered: +This skill is also invoked automatically during Phase 5 (summary) of orchestrated runs. The orchestrate engine dispatches the savings-analyzer subagent as a background {tool:Task} while the orchestrator writes the run-summary inline. When auto-triggered: - The run directory is known from the active run context - The sequence number follows the run-summary artifact - The model is Haiku (configured via the `savings_analyzer` model key, defaulting to `haiku`) -- Zero added latency: The analysis runs as a background Task while the orchestrator writes the run summary +- Zero added latency: The analysis runs as a background {tool:Task} while the orchestrator writes the run summary diff --git a/packages/agents/content/skills/orchestrate/SKILL.md b/packages/agents/content/skills/orchestrate/SKILL.md index ef54a4f9..e8bc8688 100644 --- a/packages/agents/content/skills/orchestrate/SKILL.md +++ b/packages/agents/content/skills/orchestrate/SKILL.md @@ -6,7 +6,7 @@ user-invocable: false # Orchestrate -You are a pipeline execution engine for multi-phase development workflows. You delegate ALL work to specialized subagents via the **Task tool** and use their structured output for flow control. You never write project code directly — only orchestration artifacts (run-manifest, run-summary). Run state is managed via MCP tool calls (`init_run`, `emit_event`, `register_artifact`, `complete_run`, `get_run_state`). +You are a pipeline execution engine for multi-phase development workflows. You delegate ALL work to specialized subagents via the **{tool:Task} tool** and use their structured output for flow control. You never write project code directly — only orchestration artifacts (run-manifest, run-summary). Run state is managed via MCP tool calls (`init_run`, `emit_event`, `register_artifact`, `complete_run`, `get_run_state`). Wrapper skills (`orchestrate-dev` with optional `--effort=low|medium|high`, `orchestrate-review`) configure which phases to run and invoke this engine with a pipeline specification. @@ -54,13 +54,13 @@ Model assignments determine which model each subagent uses. Resolution per key: 2. Preference: `orchestration.models.` in `.agents/preferences.yaml` then `~/.agents/preferences.yaml` 3. Engine defaults (see table below) -Resolution cascade for a given Task call: +Resolution cascade for a given {tool:Task} call: 1. Look up the agent's specific key (e.g., `holistic_reviewer` for the Phase 4b reviewer) 2. Fall back to the `default` key 3. If no `default` is configured, omit the `model` parameter (inherit from parent) -Invalid model names (e.g., `gpt4`) are rejected by the Task tool at dispatch time. +Invalid model names (e.g., `gpt4`) are rejected by the {tool:Task} tool at dispatch time. #### Engine defaults @@ -123,7 +123,7 @@ Resolution cascade: ## Visibility -Before every Task call and after every phase completion, output a status line: +Before every {tool:Task} call and after every phase completion, output a status line: - **Before:** `⏺ ── {Phase} ── Delegating to {role-emoji} {agent-name}...` - **After:** `⏺ ── {Phase} ── {outcome}` @@ -363,7 +363,7 @@ When an external plan exists with `{planTrust}` of `"low"`, always run Architect - Task is small enough for a single pass, or is a bug fix with clear scope, OR - External plan is present with `{planTrust}` of `"high"`. Emit `phase_decision` with `run: false, reason: "skipped: high-trust plan (skill: {provenance.skill}, baseSha matches main)"`. The orchestrator produces the canonical plan artifacts itself (see "High-trust plan conversion" below). -When an external plan exists with `{planTrust}` of `"medium"`, always run Planning. The planner's Task prompt includes an adoption-mode hint (see Phase 2 below). +When an external plan exists with `{planTrust}` of `"medium"`, always run Planning. The planner's {tool:Task} prompt includes an adoption-mode hint (see Phase 2 below). When an external plan exists with `{planTrust}` of `"low"`, always run Planning so the planner can validate and produce the canonical plan artifact. **Never skip Planning solely because the task already contains step-by-step instructions.** @@ -458,7 +458,7 @@ When a plan conflicts with the ticket, the ticket wins. Never override reviewer ## Turn budgets -Always pass `max_turns` explicitly to every Task call: +Always pass `max_turns` explicitly to every {tool:Task} call: | subagent_type | max_turns | | :----------------------------- | --------: | @@ -521,7 +521,7 @@ Pass the following engine-managed variables to the module: ### review-cycle: Resolving `{models}` -Pass the fully resolved models map to the module. The module uses `{models.reviewer}`, `{models.coder}`, `{models.holistic_reviewer}`, etc. to set the `model` parameter on each Task call. Resolution has already been performed during run initialization — the module receives final values, not resolution logic. +Pass the fully resolved models map to the module. The module uses `{models.reviewer}`, `{models.coder}`, `{models.holistic_reviewer}`, etc. to set the `model` parameter on each {tool:Task} call. Resolution has already been performed during run initialization — the module receives final values, not resolution logic. ### review-cycle: Resolving `{change-summary-path}` @@ -547,7 +547,7 @@ The sidecar is optional — its absence is the documented signal that nothing su Before: Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_started", phase: "architecture" } }`. -Call Task with `subagent_type: orchestrated-architect`, `max_turns: 30`, `model: {models.architect}`: +Call {tool:Task} with `subagent_type: orchestrated-architect`, `max_turns: 30`, `model: {models.architect}`: > Assess the architectural impact of the following task. > @@ -559,7 +559,7 @@ Call Task with `subagent_type: orchestrated-architect`, `max_turns: 30`, `model: > > Write your analysis to: `{run-dir}/{NN}_architect_architecture.md` -After: Store the full path as `{architecture-path}`; increment `{seq}`. Extract `Impact` using Task return parsing. Parse usage from the Task result (see "Usage capture"). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "architecture", status: "completed", tokens: {tokens}, toolUses: {toolUses}, durationMs: {durationMs}, data: { impactLevel: "{level}" } } }` (or `status: "failed"` on failure; include usage fields on failure events too when available). Call `register_artifact` for the architecture artifact. Pass architecture content downstream only if impact > `none`. +After: Store the full path as `{architecture-path}`; increment `{seq}`. Extract `Impact` using {tool:Task} return parsing. Parse usage from the {tool:Task} result (see "Usage capture"). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "architecture", status: "completed", tokens: {tokens}, toolUses: {toolUses}, durationMs: {durationMs}, data: { impactLevel: "{level}" } } }` (or `status: "failed"` on failure; include usage fields on failure events too when available). Call `register_artifact` for the architecture artifact. Pass architecture content downstream only if impact > `none`. ## Phase 2: Planning (optional) @@ -567,7 +567,7 @@ After: Store the full path as `{architecture-path}`; increment `{seq}`. Extract Before: Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_started", phase: "planning" } }`. -Call Task with `subagent_type: orchestrated-planner`, `max_turns: 40`, `model: {models.planner}`: +Call {tool:Task} with `subagent_type: orchestrated-planner`, `max_turns: 40`, `model: {models.planner}`: > Create an implementation plan for the following task. > @@ -583,13 +583,13 @@ Call Task with `subagent_type: orchestrated-planner`, `max_turns: 40`, `model: { > > Write plan files to: `{run-dir}/{NN}_planner_orchestration-plan.md` and `{run-dir}/{NN}_planner_orchestration-plan.json` -After: Store the full paths as `{plan-md-path}` and `{plan-json-path}` (both share the same `{NN}`); increment `{seq}` once for the pair. Extract `Steps` using Task return parsing. Parse usage from the Task result (see "Usage capture"). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "planning", status: "completed", tokens: {tokens}, toolUses: {toolUses}, durationMs: {durationMs}, data: { stepCount: {N} } } }` (or `status: "failed"` on failure; include usage fields on failure events too when available). Call `register_artifact` for the plan artifacts. +After: Store the full paths as `{plan-md-path}` and `{plan-json-path}` (both share the same `{NN}`); increment `{seq}` once for the pair. Extract `Steps` using {tool:Task} return parsing. Parse usage from the {tool:Task} result (see "Usage capture"). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "planning", status: "completed", tokens: {tokens}, toolUses: {toolUses}, durationMs: {durationMs}, data: { stepCount: {N} } } }` (or `status: "failed"` on failure; include usage fields on failure events too when available). Call `register_artifact` for the plan artifacts. ## Phase 3: Implementation (required) Before: Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_started", phase: "implementation" } }`. -Call Task with `subagent_type: orchestrated-coder`, `max_turns: 150`, `model: {models.coder}`: +Call {tool:Task} with `subagent_type: orchestrated-coder`, `max_turns: 150`, `model: {models.coder}`: > Implement the following changes. > @@ -604,7 +604,7 @@ Call Task with `subagent_type: orchestrated-coder`, `max_turns: 150`, `model: {m Pass all plan steps at once — the coder decides execution order. -After: Store the full path as `{change-summary-path}`; increment `{seq}` once for the dispatch (whether or not the sidecar was written — see "Artifact sequencing"). Extract `Status` and `QualityGates` using Task return parsing. Parse usage from the Task result (see "Usage capture"). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "implementation", status: "completed", tokens: {tokens}, toolUses: {toolUses}, durationMs: {durationMs}, data: { qualityGates: "{passed|failed|skipped}" } } }` (or `status: "failed"` on failure; include usage fields on failure events too when available). Call `register_artifact` for the change-summary artifact. +After: Store the full path as `{change-summary-path}`; increment `{seq}` once for the dispatch (whether or not the sidecar was written — see "Artifact sequencing"). Extract `Status` and `QualityGates` using {tool:Task} return parsing. Parse usage from the {tool:Task} result (see "Usage capture"). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "implementation", status: "completed", tokens: {tokens}, toolUses: {toolUses}, durationMs: {durationMs}, data: { qualityGates: "{passed|failed|skipped}" } } }` (or `status: "failed"` on failure; include usage fields on failure events too when available). Call `register_artifact` for the change-summary artifact. After registering the change-summary, scan `{run-dir}` for files matching `{NN}_coder_reviewer-context.md` (the same `{NN}` consumed by the change-summary). If the file exists, call `register_artifact` for it with: @@ -633,7 +633,7 @@ Use `{seq}` to continue artifact sequencing for the Phase 5 run-summary artifact ## Phase 5: Summary (always) -Dispatch the savings-analyzer subagent as a background Task and immediately proceed to write the run-summary inline (do not wait for the Task to complete before continuing). The savings analyzer runs concurrently with the orchestrator's inline summary work. +Dispatch the savings-analyzer subagent as a background {tool:Task} and immediately proceed to write the run-summary inline (do not wait for the {tool:Task} to complete before continuing). The savings analyzer runs concurrently with the orchestrator's inline summary work. - `subagent_type: savings-analyzer` - `max_turns: 15` @@ -723,7 +723,7 @@ The orchestrator's `provenance.model` is omitted — the run-summary aggregates After writing the artifact, call `register_artifact` for the run-summary artifact. Present the same summary to the user in the conversation. The conversational output should match the artifact content — do not abbreviate or omit sections. -After the savings-analyzer Task completes (it runs concurrently and will finish while or after the run-summary is written), call `register_artifact` with: +After the savings-analyzer {tool:Task} completes (it runs concurrently and will finish while or after the run-summary is written), call `register_artifact` with: ``` runDir: {run-dir} @@ -757,11 +757,11 @@ If the run-summary has no deferred items and no insights, skip this phase silent See [artifact-conventions.md](../_data/artifact-conventions.md) for artifact naming, flow-control field locations, and the example run directory layout. -## Task return parsing +## {tool:Task} return parsing -Subagents include a structured return block at the end of their Task response. The orchestrator parses flow-control fields directly from this return value. +Subagents include a structured return block at the end of their {tool:Task} response. The orchestrator parses flow-control fields directly from this return value. -**Parse format:** look for lines matching `{Key}: {value}` in the Task return. Expected fields per role: +**Parse format:** look for lines matching `{Key}: {value}` in the {tool:Task} return. Expected fields per role: - **Architect:** `Phase`, `Status`, `Artifact`, `Impact` (`none`|`low`|`medium`|`high`) - **Planner:** `Phase`, `Status`, `Artifact`, `Steps` (integer) @@ -772,15 +772,15 @@ Subagents include a structured return block at the end of their Task response. T ## Usage capture -Task results include a `` block reporting resource consumption. Parse these fields and map them to event fields for downstream analysis. +{tool:Task} results include a `` block reporting resource consumption. Parse these fields and map them to event fields for downstream analysis. -**Parse format:** look for a `` block in the Task return value. Extract key-value pairs: +**Parse format:** look for a `` block in the {tool:Task} return value. Extract key-value pairs: -| Task result field | Event field | -| ----------------- | ------------ | -| `total_tokens` | `tokens` | -| `tool_uses` | `toolUses` | -| `duration_ms` | `durationMs` | +| {tool:Task} result field | Event field | +| ------------------------ | ------------ | +| `total_tokens` | `tokens` | +| `tool_uses` | `toolUses` | +| `duration_ms` | `durationMs` | **Parsing rules:** @@ -792,7 +792,7 @@ Task results include a `` block reporting resource consumption. Parse the - **Subagent failure**: Emit `phase_completed` with `status: "failed"`, retry same phase once. If retry fails, emit `phase_completed` with `status: "failed"` again and proceed to summary. - **`max_turns` exhausted (reviewers):** The engine dispatches one constrained retry per the "Retry-on-interruption hook" in `modules/review-cycle.md`. The retry uses a constrained prompt shape (file allow-list, negative-scope guardrails, forced structured return) and does not consume from `reviewRoundsUsed`. If the retry also exhausts, fall through to **Recovery from reviewer interruption** below. Applies to all five reviewers (`orchestrated-reviewer`, `aspect-code-reviewer`, `aspect-silent-failure-reviewer`, `aspect-test-reviewer`, `code-simplification-reviewer`). - **`max_turns` exhausted (non-reviewers):** For subagents without a dedicated recovery path, record as `needs_manual_review`. The coder has its own continuation path (see **Recovery from coder interruption** below). -- **Recovery from coder interruption**: When a coder Task returns without a structured return block (typically an `agentId:` marker on `max_turns` exhaustion), the coder maintains its change-summary incrementally — the partial artifact at the canonical `{run-dir}/{NN}_coder_change-summary.md` path will list which plan tasks or findings were completed vs. pending. Read the partial summary and use it to seed a continuation dispatch or populate the run summary. Do NOT fall back to working-tree inspection; the partial artifact is the authoritative state-transfer channel. +- **Recovery from coder interruption**: When a coder {tool:Task} returns without a structured return block (typically an `agentId:` marker on `max_turns` exhaustion), the coder maintains its change-summary incrementally — the partial artifact at the canonical `{run-dir}/{NN}_coder_change-summary.md` path will list which plan tasks or findings were completed vs. pending. Read the partial summary and use it to seed a continuation dispatch or populate the run summary. Do NOT fall back to working-tree inspection; the partial artifact is the authoritative state-transfer channel. - **Recovery from reviewer interruption**: Applies after the constrained retry (per the **`max_turns` exhausted (reviewers)** rule above) has also exhausted. The reviewer maintains its review file incrementally — read the partial artifact at the canonical reviewer path (`{run-dir}/{NN}_{reviewer}_*.md`). Inspect the `### Criticality:` line: if it is the literal sentinel `(pending)`, the reviewer did not converge. Treat the dispatch as `failed` for flow control purposes, but retain the partial findings list to inform the run summary. Do NOT use `(pending)` as a criticality value in aggregation — it is not in the enum. Do NOT fall back to working-tree inspection; the partial artifact is the authoritative state-transfer channel. See the `failed`-reviewer rule in `modules/review-cycle.md`'s "Handling failures" note for how the reviewer's contribution to aggregated criticality is computed (`medium`). - **Reviewer recovery scope:** The retry hook and reviewer-interruption recovery rules apply uniformly to all five reviewers. The `### Criticality: (pending)` sentinel in the artifact file is the unified interruption marker — `code-simplification-reviewer` is included despite having no structured return block, because the file-side sentinel is the authoritative trigger. - **Quality gate failure** (coder reports failing gates): Treat as review finding at `critical` severity. diff --git a/packages/agents/content/skills/orchestrate/modules/review-cycle.md b/packages/agents/content/skills/orchestrate/modules/review-cycle.md index bdf57b25..98f5fed2 100644 --- a/packages/agents/content/skills/orchestrate/modules/review-cycle.md +++ b/packages/agents/content/skills/orchestrate/modules/review-cycle.md @@ -123,7 +123,7 @@ The retry prompt is assembled by prepending parts 1-3 above the original prompt ### Resolution - **`{file-allow-list}`** — extracted from the interrupted reviewer's partial artifact at its original write-target path. Take all file paths cited in the partial's findings list (the `### Findings` section) and any paths cited elsewhere in the scaffold. Deduplicate. If the partial yields no file references, fall back to the full `{changed-files}` set computed at the dispatch site. -- **`{peer-coverage-summary}`** — for Phase 4 retries, draw from peer reviewers in the same parallel batch whose Task return parsed cleanly with a finalized `### Criticality:` enum value. For Phase 4a and Phase 4b retries, draw from the Phase 4 batch's completed reviewers (always available by that point). Format as a comma-separated list of `{reviewer-name}: {one-line scope or focus area}` entries derived from each peer's findings file. If no peer findings are available, the negative-scope block is omitted entirely. +- **`{peer-coverage-summary}`** — for Phase 4 retries, draw from peer reviewers in the same parallel batch whose {tool:Task} return parsed cleanly with a finalized `### Criticality:` enum value. For Phase 4a and Phase 4b retries, draw from the Phase 4 batch's completed reviewers (always available by that point). Format as a comma-separated list of `{reviewer-name}: {one-line scope or focus area}` entries derived from each peer's findings file. If no peer findings are available, the negative-scope block is omitted entirely. ## Retry-on-interruption hook @@ -184,11 +184,11 @@ Call MCP tool emit_event with: event: { event: "reviewer_dispatched", reviewer: "{reviewer-name}" } ``` -Send all activated Task calls in a single message so they run concurrently. Each agent examines the branch diff independently. +Send all activated {tool:Task} calls in a single message so they run concurrently. Each agent examines the branch diff independently. Before dispatching, assign `{NN}` values and store named path variables for each activated reviewer using these names and this order: `{core-review-path}` (core reviewer, always), `{sf-review-path}` (silent-failure reviewer, if activated), `{test-review-path}` (test reviewer, if activated), `{code-review-path}` (code reviewer, if activated). Skipped reviewers do not consume a sequence number; increment `{seq}` only for activated reviewers. -Call Task with `subagent_type: orchestrated-reviewer`, `max_turns: 60`, `model: {models.reviewer}`: +Call {tool:Task} with `subagent_type: orchestrated-reviewer`, `max_turns: 60`, `model: {models.reviewer}`: > Review the code changes for the following task. > @@ -206,7 +206,7 @@ Call Task with `subagent_type: orchestrated-reviewer`, `max_turns: 60`, `model: > > {If `{reviewer-context}` is non-empty, append: `## Reviewer context\n\n{reviewer-context}` (see "Reviewer-context assembly" above). Omit the entire block when `{reviewer-context}` is empty — do not emit an empty heading.} -Call Task with `subagent_type: aspect-silent-failure-reviewer`, `max_turns: 45`, `model: {models.aspect_silent_failure_reviewer}` (if activated): +Call {tool:Task} with `subagent_type: aspect-silent-failure-reviewer`, `max_turns: 45`, `model: {models.aspect_silent_failure_reviewer}` (if activated): > Review the code changes on this branch for error-handling and silent-failure issues. > @@ -221,7 +221,7 @@ Call Task with `subagent_type: aspect-silent-failure-reviewer`, `max_turns: 45`, > > {If `{reviewer-context}` is non-empty, append: `## Reviewer context\n\n{reviewer-context}` (see "Reviewer-context assembly" above). Omit when empty.} -Call Task with `subagent_type: aspect-test-reviewer`, `max_turns: 45`, `model: {models.aspect_test_reviewer}` (if activated): +Call {tool:Task} with `subagent_type: aspect-test-reviewer`, `max_turns: 45`, `model: {models.aspect_test_reviewer}` (if activated): > Review the code changes on this branch for test-coverage quality, behavioral gaps, and missing edge cases. > @@ -240,7 +240,7 @@ Call Task with `subagent_type: aspect-test-reviewer`, `max_turns: 45`, `model: { > > {If `{reviewer-context}` is non-empty, append: `## Reviewer context\n\n{reviewer-context}` (see "Reviewer-context assembly" above). Omit when empty.} -Call Task with `subagent_type: aspect-code-reviewer`, `max_turns: 45`, `model: {models.aspect_code_reviewer}` (if activated): +Call {tool:Task} with `subagent_type: aspect-code-reviewer`, `max_turns: 45`, `model: {models.aspect_code_reviewer}` (if activated): > Review the code changes on this branch for CLAUDE.md compliance, bugs, and logic errors. > @@ -261,7 +261,7 @@ After the parallel batch returns and before parsing usage or aggregating finding ### Findings aggregation -After all dispatched reviewers complete, parse usage from each reviewer's Task result (see "Usage capture" in SKILL.md). Emit one `reviewer_completed` event per dispatched reviewer: +After all dispatched reviewers complete, parse usage from each reviewer's {tool:Task} result (see "Usage capture" in SKILL.md). Emit one `reviewer_completed` event per dispatched reviewer: ``` Call MCP tool emit_event with: @@ -282,7 +282,7 @@ Call MCP tool emit_event with: Then aggregate findings from all sources into a consolidated set. -**Criticality aggregation:** For each reviewer, extract `Criticality` using Task return parsing (see SKILL.md). If extraction fails, treat that reviewer's criticality as `medium`. The **aggregated criticality** is the maximum across all active reviewers: `high` > `medium` > `low` > `none`. Skipped aspect reviewers do not contribute to aggregation. +**Criticality aggregation:** For each reviewer, extract `Criticality` using {tool:Task} return parsing (see SKILL.md). If extraction fails, treat that reviewer's criticality as `medium`. The **aggregated criticality** is the maximum across all active reviewers: `high` > `medium` > `low` > `none`. Skipped aspect reviewers do not contribute to aggregation. **Deduplication heuristics:** If multiple reviewers flag the same file and line range (within 3 lines) with similar descriptions, consolidate into a single finding attributed to all relevant reviewers. When in doubt, keep findings separate — false deduplication is worse than redundant findings. Read each reviewer's artifact file to access finding details for deduplication and the consolidated coder fix prompt. @@ -306,7 +306,7 @@ Before applying these rules, check the iteration budget. If N iterations have be Before: Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "coder_fix_started", iteration: {N} } }`. -Call Task with `subagent_type: orchestrated-coder`, `max_turns: 150`, `model: {models.coder}`: +Call {tool:Task} with `subagent_type: orchestrated-coder`, `max_turns: 150`, `model: {models.coder}`: > Address the review findings for the following task. > @@ -326,7 +326,7 @@ Call Task with `subagent_type: orchestrated-coder`, `max_turns: 150`, `model: {m > > Write your response to: `{run-dir}/{NN}_coder_change-summary.md` -After: Update `{change-summary-path}` to the new file; increment `{seq}`. Parse usage from the coder's Task result (see "Usage capture" in SKILL.md). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "coder_fix_completed", iteration: {N}, tokens: {tokens}, toolUses: {toolUses}, durationMs: {durationMs} } }`. Call `register_artifact` for the coder's change-summary artifact. +After: Update `{change-summary-path}` to the new file; increment `{seq}`. Parse usage from the coder's {tool:Task} result (see "Usage capture" in SKILL.md). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "coder_fix_completed", iteration: {N}, tokens: {tokens}, toolUses: {toolUses}, durationMs: {durationMs} } }`. Call `register_artifact` for the coder's change-summary artifact. ### Selective re-review @@ -340,7 +340,7 @@ If re-review is warranted, assign new `{NN}` values for each re-dispatched revie Recompute `{changed-files}` (a coder fix cycle may have added or removed files) and re-run the reviewer-context assembly steps to produce a fresh `{reviewer-context}`. The re-review prompts use the freshly computed value — do not reuse the value captured at initial dispatch time. `{reviewer-context-sidecar-path}` does not need to be re-resolved here: Fix-cycle coder prompts do not supply a sidecar path, so no new sidecar can appear during a Phase 4 fix cycle. -Send re-review Task calls in a single message (parallel) using the same prompts, models, and turn budgets as the initial dispatch but adding context: +Send re-review {tool:Task} calls in a single message (parallel) using the same prompts, models, and turn budgets as the initial dispatch but adding context: > {Same prompt as initial dispatch — including the conditional `## Reviewer context` block from "Reviewer-context assembly" — with this addition:} > @@ -350,7 +350,7 @@ If a re-reviewer fails or times out, treat its original findings as unverified a After the parallel re-dispatch returns and before parsing usage, apply the "Retry-on-interruption hook" (see above) per re-reviewer. Re-reviews are subject to the hook on the same terms as initial dispatches. -After re-reviews complete: Parse usage from each re-reviewer's Task result (see "Usage capture" in SKILL.md). Aggregate usage across all re-review Task results by summing `tokens`, `toolUses`, and `durationMs` independently. Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "re_review_completed", criticalities: { "{name}": "{level}", ... }, tokens: {summed-tokens}, toolUses: {summed-toolUses}, durationMs: {summed-durationMs} } }`. Call `register_artifact` for each re-reviewer's artifact file. +After re-reviews complete: Parse usage from each re-reviewer's {tool:Task} result (see "Usage capture" in SKILL.md). Aggregate usage across all re-review {tool:Task} results by summing `tokens`, `toolUses`, and `durationMs` independently. Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "re_review_completed", criticalities: { "{name}": "{level}", ... }, tokens: {summed-tokens}, toolUses: {summed-toolUses}, durationMs: {summed-durationMs} } }`. Call `register_artifact` for each re-reviewer's artifact file. Aggregate findings again using the same rules. If new actionable findings emerge and review rounds remain (< N), loop back: Run another coder fix cycle, then selective re-review. Repeat until convergence (aggregated criticality is `none`, or below both thresholds, or below approval_threshold with no remaining budget) or the iteration budget is exhausted. @@ -361,7 +361,7 @@ Call MCP tool `get_run_state` with `{ runDir: {run-dir} }`. Use the returned `re - After N iterations unresolved (where N is the configured `max-review-rounds`): Exit with `needs_manual_review` status. The iteration count includes the initial review dispatch as round 1 and each selective re-review as an additional round. With N=1, only the initial review dispatch runs — if findings exist, the phase exits as `needs_manual_review` with no fix attempt. Set N >= 2 for effective iterative review. - Structural issues: May return to Planning once per run. -At phase completion (converged or `needs_manual_review`): Compute aggregate usage for the entire review phase by summing `tokens`, `toolUses`, and `durationMs` across all Task calls within Phase 4 (all reviewer dispatches, coder fix cycles, and re-reviews). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "review", status: "completed"|"failed"|"needs_manual_review", tokens: {aggregate-tokens}, toolUses: {aggregate-toolUses}, durationMs: {aggregate-durationMs}, data: { aggregatedCriticality: "{level}", reviewRoundsUsed: {N} } } }`. Then emit `phase_decision` for `parallelReview`: +At phase completion (converged or `needs_manual_review`): Compute aggregate usage for the entire review phase by summing `tokens`, `toolUses`, and `durationMs` across all {tool:Task} calls within Phase 4 (all reviewer dispatches, coder fix cycles, and re-reviews). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "review", status: "completed"|"failed"|"needs_manual_review", tokens: {aggregate-tokens}, toolUses: {aggregate-toolUses}, durationMs: {aggregate-durationMs}, data: { aggregatedCriticality: "{level}", reviewRoundsUsed: {N} } } }`. Then emit `phase_decision` for `parallelReview`: ``` Call MCP tool emit_event with: @@ -389,7 +389,7 @@ If Phase 4a will run: Call MCP tool `emit_event` with `{ runDir: {run-dir}, even If Phase 4a is skipped: Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "simplifier", status: "skipped" } }`. -Call Task with `subagent_type: code-simplification-reviewer`, `max_turns: 30`, `model: {models.code_simplification_reviewer}`: +Call {tool:Task} with `subagent_type: code-simplification-reviewer`, `max_turns: 30`, `model: {models.code_simplification_reviewer}`: > Review the code changes on this branch for simplification opportunities. > @@ -408,7 +408,7 @@ Call Task with `subagent_type: code-simplification-reviewer`, `max_turns: 30`, ` After: Store the full path as `{simplifier-review-path}`; increment `{seq}`. Apply the "Retry-on-interruption hook" (see above) — the simplifier uses the same `### Criticality: (pending)` sentinel as the other reviewers; any partial artifact triggers one constrained retry before findings are read. Then read the findings file. Code-simplification-reviewer findings are NOT re-reviewed by other agents. If the code-simplification-reviewer produced actionable findings, run one coder fix cycle. If the coder fix cycle fails, emit `phase_completed` with `status: "failed"` and proceed to Phase 4b. -Call Task with `subagent_type: orchestrated-coder`, `max_turns: 150`, `model: {models.coder}`: +Call {tool:Task} with `subagent_type: orchestrated-coder`, `max_turns: 150`, `model: {models.coder}`: > Address the code simplification findings for the following task. > @@ -420,7 +420,7 @@ Call Task with `subagent_type: orchestrated-coder`, `max_turns: 150`, `model: {m > > Write your response to: `{run-dir}/{NN}_coder_change-summary.md` -After: If a coder fix cycle ran, update `{change-summary-path}` to the new file; increment `{seq}`. Compute aggregate usage for the simplifier phase by summing `tokens`, `toolUses`, and `durationMs` across all Task calls within Phase 4a (the code-simplification-reviewer dispatch and, if applicable, the coder fix cycle). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "simplifier", status: "completed", tokens: {aggregate-tokens}, toolUses: {aggregate-toolUses}, durationMs: {aggregate-durationMs}, data: { actionableFindings: true|false, coderFixCycleRan: true|false } } }` (or `status: "failed"` on failure; include usage fields on failure events too when available). Call `register_artifact` for the code-simplification-reviewer review artifact. If a coder fix cycle ran, also call `register_artifact` for the coder change-summary artifact. +After: If a coder fix cycle ran, update `{change-summary-path}` to the new file; increment `{seq}`. Compute aggregate usage for the simplifier phase by summing `tokens`, `toolUses`, and `durationMs` across all {tool:Task} calls within Phase 4a (the code-simplification-reviewer dispatch and, if applicable, the coder fix cycle). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "simplifier", status: "completed", tokens: {aggregate-tokens}, toolUses: {aggregate-toolUses}, durationMs: {aggregate-durationMs}, data: { actionableFindings: true|false, coderFixCycleRan: true|false } } }` (or `status: "failed"` on failure; include usage fields on failure events too when available). Call `register_artifact` for the code-simplification-reviewer review artifact. If a coder fix cycle ran, also call `register_artifact` for the coder change-summary artifact. ## Phase 4b: Final comprehensive review @@ -443,7 +443,7 @@ If Phase 4b will run: Call MCP tool `emit_event` with `{ runDir: {run-dir}, even If Phase 4b is skipped: Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "holistic", status: "skipped" } }`. Set `{review-status}` to `needs_manual_review` and exit the module. -Call Task with `subagent_type: orchestrated-reviewer`, `max_turns: 60`, `model: {models.holistic_reviewer}`: +Call {tool:Task} with `subagent_type: orchestrated-reviewer`, `max_turns: 60`, `model: {models.holistic_reviewer}`: > Perform a final review of all changes on this branch. > @@ -470,7 +470,7 @@ Store the full path as `{holistic-review-path}`; increment `{seq}`. Apply the "R ### Flow control -Extract `Criticality` using Task return parsing (see SKILL.md). +Extract `Criticality` using {tool:Task} return parsing (see SKILL.md). Call MCP tool `get_run_state` with `{ runDir: {run-dir} }`. Use the returned state to read total `reviewRoundsUsed` across Phase 4 and 4b combined for the budget decision below. @@ -482,4 +482,4 @@ Call MCP tool `get_run_state` with `{ runDir: {run-dir} }`. Use the returned sta When a Phase 4b re-review runs, recompute the reviewer-context block before re-dispatching (re-run the assembly steps to produce a fresh `{reviewer-context}`). `{reviewer-context-sidecar-path}` does not need to be re-resolved: Fix-cycle coder prompts do not supply a sidecar path, so no new sidecar can appear. The re-review prompt uses the same conditional `## Reviewer context` block as the initial Phase 4b dispatch. Apply the "Retry-on-interruption hook" (see above) after the re-review returns; re-reviews are subject to the hook on the same terms as initial dispatches. -After: Compute aggregate usage for the holistic phase by summing `tokens`, `toolUses`, and `durationMs` across all Task calls within Phase 4b (the holistic reviewer dispatch and, if applicable, coder fix and re-review cycles). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "holistic", status: "completed"|"needs_manual_review", tokens: {aggregate-tokens}, toolUses: {aggregate-toolUses}, durationMs: {aggregate-durationMs}, data: { criticality: "{level}" } } }`. Call `register_artifact` for any coder change-summary artifacts produced during Phase 4b fix cycles. +After: Compute aggregate usage for the holistic phase by summing `tokens`, `toolUses`, and `durationMs` across all {tool:Task} calls within Phase 4b (the holistic reviewer dispatch and, if applicable, coder fix and re-review cycles). Call MCP tool `emit_event` with `{ runDir: {run-dir}, event: { event: "phase_completed", phase: "holistic", status: "completed"|"needs_manual_review", tokens: {aggregate-tokens}, toolUses: {aggregate-toolUses}, durationMs: {aggregate-durationMs}, data: { criticality: "{level}" } } }`. Call `register_artifact` for any coder change-summary artifacts produced during Phase 4b fix cycles. diff --git a/packages/agents/content/skills/plan-orchestrable-steps/SKILL.md b/packages/agents/content/skills/plan-orchestrable-steps/SKILL.md index 481ea91c..66b7366c 100644 --- a/packages/agents/content/skills/plan-orchestrable-steps/SKILL.md +++ b/packages/agents/content/skills/plan-orchestrable-steps/SKILL.md @@ -14,7 +14,7 @@ Decompose a story or task into independently orchestrable implementation steps. ## Visibility -Before every Task call and after every phase completion, output a status line: +Before every {tool:Task} call and after every phase completion, output a status line: - **Before:** `── Planning ── delegating to planner...` - **After:** `── Planning ── {step count} steps, {question count} questions` @@ -32,7 +32,7 @@ Before every Task call and after every phase completion, output a status line: Generate a UTC timestamp: `{YYYYMMDD-HHMMSSZ}`. -Call Task with `subagent_type: planner`, `max_turns: 40`: +Call {tool:Task} with `subagent_type: planner`, `max_turns: 40`: > Break the following story into independently orchestrable implementation steps. > @@ -65,7 +65,7 @@ Wait for user input. The user may: If the user provides feedback (not approval): 1. Generate a new UTC timestamp for the updated plan.md. -2. Re-invoke the planner agent with the feedback. Call Task with `subagent_type: planner`, `max_turns: 40`: +2. Re-invoke the planner agent with the feedback. Call {tool:Task} with `subagent_type: planner`, `max_turns: 40`: > Update the plan based on user feedback. > diff --git a/packages/agents/content/skills/refine-plan/SKILL.md b/packages/agents/content/skills/refine-plan/SKILL.md index 6c0c2733..a2fa4880 100644 --- a/packages/agents/content/skills/refine-plan/SKILL.md +++ b/packages/agents/content/skills/refine-plan/SKILL.md @@ -15,7 +15,7 @@ Perform a single review-and-revise round on a saved implementation plan, checkin ## Visibility -Before every Task call and after every phase completion, output a status line: +Before every {tool:Task} call and after every phase completion, output a status line: - **Before dispatch:** `-- Refine plan -- delegating to {agent}...` - **After completion:** `-- Refine plan -- {summary}` @@ -29,7 +29,7 @@ Before every Task call and after every phase completion, output a status line: 3. Resolve the ticket source: - GitHub URL (`github.com/.../issues/...`) -> use `gh issue view --json title,body {url}` via Bash to fetch content. - File path -> Read the file. - - Other URL -> use WebFetch to retrieve content. + - Other URL -> Fetch the URL content. 4. Use `get-session-context` to obtain `ticket_id`, `project_slug`, and `artifact_base_dir`. 5. Resolve artifact directory: `{artifact_base_dir}/projects/{project_slug}/tickets/{ticket_id}/` 6. `mkdir -p {artifact_dir}` @@ -51,7 +51,7 @@ Set the review output path: `{artifact_dir}/{timestamp}_{slug}_plan-review.md` `-- Refine plan -- delegating to plan-reviewer...` -Call Task with `subagent_type: plan-reviewer`, `max_turns: 30`: +Call {tool:Task} with `subagent_type: plan-reviewer`, `max_turns: 30`: > Review the following implementation plan for completeness and correctness. > @@ -118,7 +118,7 @@ Set the revision output path: `{artifact_dir}/{new_timestamp}_{slug}_plan-v2.md` `-- Refine plan -- delegating to plan-reviser...` -Call Task with `subagent_type: plan-reviser`, `max_turns: 30`: +Call {tool:Task} with `subagent_type: plan-reviser`, `max_turns: 30`: > Revise the following implementation plan based on review findings and user answers. > @@ -138,7 +138,7 @@ Parse the return block: `-- Refine plan -- revision complete` -If the plan-reviser Task failed or the return block does not have `Status: completed`, skip the provenance update and report the failure: +If the plan-reviser {tool:Task} failed or the return block does not have `Status: completed`, skip the provenance update and report the failure: ``` Plan revision failed -- the plan-reviser did not complete successfully. diff --git a/packages/agents/content/subagents/_data/claude.yml b/packages/agents/content/subagents/_data/claude.yml index 3260c505..7b6d1f3a 100644 --- a/packages/agents/content/subagents/_data/claude.yml +++ b/packages/agents/content/subagents/_data/claude.yml @@ -10,6 +10,7 @@ _tools: Glob: Glob Grep: Grep Read: Read + Task: Task Write: Write _defaults: diff --git a/packages/agents/content/subagents/_data/rovodev.yml b/packages/agents/content/subagents/_data/rovodev.yml index baca3c8a..330cf5ee 100644 --- a/packages/agents/content/subagents/_data/rovodev.yml +++ b/packages/agents/content/subagents/_data/rovodev.yml @@ -11,6 +11,7 @@ _tools: Glob: expand_folder Grep: grep Read: open_files + Task: invoke_subagent Write: create_file _defaults: From 4d4c8c8b4e359301b1e667ac7d0acda9551c6259 Mon Sep 17 00:00:00 2001 From: William Thorsen Date: Sun, 17 May 2026 22:20:52 -0700 Subject: [PATCH 2/2] agents|refactor: Change platform file extensions from yml to yaml --- packages/agents/content/_partials/README.md | 6 +++--- .../content/subagents/_data/{claude.yml => claude.yaml} | 2 +- .../content/subagents/_data/{rovodev.yml => rovodev.yaml} | 2 +- .../agents/src/commands/__tests__/install-includes.test.ts | 2 +- .../src/commands/__tests__/install-tool-names.test.ts | 2 +- packages/agents/src/lib/platform.ts | 4 ++-- 6 files changed, 9 insertions(+), 9 deletions(-) rename packages/agents/content/subagents/_data/{claude.yml => claude.yaml} (98%) rename packages/agents/content/subagents/_data/{rovodev.yml => rovodev.yaml} (98%) diff --git a/packages/agents/content/_partials/README.md b/packages/agents/content/_partials/README.md index 9d104620..bcabc0ca 100644 --- a/packages/agents/content/_partials/README.md +++ b/packages/agents/content/_partials/README.md @@ -40,7 +40,7 @@ The `_partials` directory itself never appears in installed output. For each `.md` source file the install pipeline performs, in order: 1. **Expand includes.** `expandIncludes(srcPath, contentDir)` resolves all directive shapes recursively and substitutes slot content. -2. **Merge frontmatter** (subagents only). Platform-specific frontmatter overrides from `_data/{platform}.yml` are merged into the source's frontmatter. +2. **Merge frontmatter** (subagents only). Platform-specific frontmatter overrides from `_data/{platform}.yaml` are merged into the source's frontmatter. 3. **Rewrite tool-name placeholders.** `rewriteToolNames(content, mapping)` replaces each `{tool:NAME}` placeholder using the platform's `_tools:` mapping from the same overlay YAML. An unmapped name is a fatal install error anchored to the source file and line. See [Tool-name placeholders](#tool-name-placeholders). 4. **Inject the provenance marker.** A `GENERATED FILE` comment is added at the top of the output, with a `Source:` link to the original file. 5. **Rewrite paths** (skills only, post-write). Bare-relative Markdown links are rewritten to absolute platform paths. @@ -52,10 +52,10 @@ Expansion runs before the dry-run gate, so missing partials, cycles, and out-of- ## Tool-name placeholders -Subagent and skill body text reference tools using the `{tool:NAME}` placeholder so the same source can install for platforms that name their tools differently. `NAME` is the canonical (Claude) tool name (`Read`, `Write`, `Edit`, `Bash`, `Grep`, `Glob`). The install pipeline rewrites each placeholder using the platform's `_tools:` mapping, which lives at the top of each overlay YAML at `content/subagents/_data/{platform}.yml`. +Subagent and skill body text reference tools using the `{tool:NAME}` placeholder so the same source can install for platforms that name their tools differently. `NAME` is the canonical (Claude) tool name (`Read`, `Write`, `Edit`, `Bash`, `Grep`, `Glob`). The install pipeline rewrites each placeholder using the platform's `_tools:` mapping, which lives at the top of each overlay YAML at `content/subagents/_data/{platform}.yaml`. ```yaml -# content/subagents/_data/rovodev.yml +# content/subagents/_data/rovodev.yaml _tools: Bash: bash Edit: find_and_replace_code diff --git a/packages/agents/content/subagents/_data/claude.yml b/packages/agents/content/subagents/_data/claude.yaml similarity index 98% rename from packages/agents/content/subagents/_data/claude.yml rename to packages/agents/content/subagents/_data/claude.yaml index 7b6d1f3a..c3fe3d46 100644 --- a/packages/agents/content/subagents/_data/claude.yml +++ b/packages/agents/content/subagents/_data/claude.yaml @@ -1,4 +1,4 @@ -# claude.yml +# claude.yaml # Body-text tool-name mapping for the {tool:NAME} placeholder rewriter. # Authoring guide: ../../_partials/README.md (Tool-name placeholders). diff --git a/packages/agents/content/subagents/_data/rovodev.yml b/packages/agents/content/subagents/_data/rovodev.yaml similarity index 98% rename from packages/agents/content/subagents/_data/rovodev.yml rename to packages/agents/content/subagents/_data/rovodev.yaml index 330cf5ee..4f7974fa 100644 --- a/packages/agents/content/subagents/_data/rovodev.yml +++ b/packages/agents/content/subagents/_data/rovodev.yaml @@ -1,4 +1,4 @@ -# rovodev.yml +# rovodev.yaml # Body-text tool-name mapping for the {tool:NAME} placeholder rewriter. # Authoring guide: ../../_partials/README.md (Tool-name placeholders). diff --git a/packages/agents/src/commands/__tests__/install-includes.test.ts b/packages/agents/src/commands/__tests__/install-includes.test.ts index 73b1a820..a91834d1 100644 --- a/packages/agents/src/commands/__tests__/install-includes.test.ts +++ b/packages/agents/src/commands/__tests__/install-includes.test.ts @@ -57,7 +57,7 @@ describe('install with include directives', () => { '# Claude guidance\n', 'utf8', ); - await writeFile(path.join(contentDir, 'subagents', '_data', 'claude.yml'), '_defaults: {}\n', 'utf8'); + await writeFile(path.join(contentDir, 'subagents', '_data', 'claude.yaml'), '_defaults: {}\n', 'utf8'); for (const [name, body] of Object.entries(options.subagents ?? {})) { await writeFile(path.join(contentDir, 'subagents', name), body, 'utf8'); diff --git a/packages/agents/src/commands/__tests__/install-tool-names.test.ts b/packages/agents/src/commands/__tests__/install-tool-names.test.ts index 4d512c99..2a0b2a10 100644 --- a/packages/agents/src/commands/__tests__/install-tool-names.test.ts +++ b/packages/agents/src/commands/__tests__/install-tool-names.test.ts @@ -30,7 +30,7 @@ describe('tool-name placeholder rewriting end-to-end', () => { // Minimal Rovo Dev overlay with a complete _tools: mapping. await writeFile( - path.join(contentDir, 'subagents', '_data', 'rovodev.yml'), + path.join(contentDir, 'subagents', '_data', 'rovodev.yaml'), [ '_tools:', ' Bash: bash', diff --git a/packages/agents/src/lib/platform.ts b/packages/agents/src/lib/platform.ts index b299e142..d9845826 100644 --- a/packages/agents/src/lib/platform.ts +++ b/packages/agents/src/lib/platform.ts @@ -12,7 +12,7 @@ export const PLATFORMS: Record = { skillsDir: 'skills', subagentsDir: 'agents', scriptsDir: 'scripts', - frontmatterFile: 'claude.yml', + frontmatterFile: 'claude.yaml', }, rovodev: { id: 'rovodev', @@ -20,7 +20,7 @@ export const PLATFORMS: Record = { skillsDir: 'skills', subagentsDir: 'subagents', scriptsDir: 'scripts', - frontmatterFile: 'rovodev.yml', + frontmatterFile: 'rovodev.yaml', }, };