From d8853ccc99e637a5c89bcaa21b9ff6019f81acba Mon Sep 17 00:00:00 2001 From: lorenzozanee Date: Sat, 5 Sep 2026 13:06:10 +0800 Subject: [PATCH] fix(skills): isolate uv commands from project environments --- .../agents/bmad-agent-analyst/SKILL.md | 2 +- .../agents/bmad-agent-architect/SKILL.md | 2 +- src/bmm-skills/agents/bmad-agent-dev/SKILL.md | 2 +- src/bmm-skills/agents/bmad-agent-pm/SKILL.md | 2 +- .../agents/bmad-agent-ux-designer/SKILL.md | 2 +- .../plan/bmad-architecture/SKILL.md | 8 ++-- .../bmad-create-epics-and-stories/SKILL.md | 2 +- .../steps/step-04-final-validation.md | 2 +- src/bmm-skills/plan/bmad-prd/SKILL.md | 10 ++--- .../plan/bmad-prd/references/headless.md | 2 +- src/bmm-skills/plan/bmad-prfaq/SKILL.md | 2 +- .../plan/bmad-prfaq/references/verdict.md | 2 +- .../plan/bmad-product-brief/SKILL.md | 8 ++-- .../plan/bmad-project-context/SKILL.md | 4 +- src/bmm-skills/plan/bmad-spec/SKILL.md | 8 ++-- .../plan/bmad-sprint-planning/SKILL.md | 2 +- src/bmm-skills/plan/bmad-ux/SKILL.md | 10 ++--- .../plan/bmad-ux/references/headless.md | 2 +- src/bmm-skills/ship/bmad-build-auto/SKILL.md | 2 +- src/bmm-skills/ship/bmad-build/SKILL.md | 2 +- src/bmm-skills/ship/bmad-code-review/SKILL.md | 2 +- .../bmad-code-review/steps/step-04-present.md | 2 +- .../ship/bmad-correct-course/SKILL.md | 4 +- .../ship/bmad-qa-generate-e2e-tests/SKILL.md | 4 +- .../ship/bmad-retrospective/SKILL.md | 2 +- src/bmm-skills/ship/bmad-walkthrough/SKILL.md | 2 +- .../ship/bmad-walkthrough/step-05-wrapup.md | 2 +- .../bmad-create-architecture/SKILL.md | 2 +- .../v6-shims/bmad-create-prd/SKILL.md | 2 +- .../v6-shims/bmad-create-story/SKILL.md | 4 +- .../v6-shims/bmad-dev-story/SKILL.md | 4 +- .../v6-shims/bmad-domain-research/SKILL.md | 2 +- .../v6-shims/bmad-edit-prd/SKILL.md | 2 +- .../v6-shims/bmad-market-research/SKILL.md | 2 +- .../v6-shims/bmad-sprint-status/SKILL.md | 2 +- .../v6-shims/bmad-technical-research/SKILL.md | 2 +- .../v6-shims/bmad-validate-prd/SKILL.md | 2 +- .../bmad-advanced-elicitation/SKILL.md | 4 +- src/core-skills/bmad-brainstorming/SKILL.md | 10 ++--- .../bmad-brainstorming/references/converge.md | 2 +- .../bmad-brainstorming/references/finalize.md | 2 +- .../bmad-brainstorming/references/headless.md | 6 +-- .../references/mode-autonomous.md | 2 +- src/core-skills/bmad-customize/SKILL.md | 2 +- src/core-skills/bmad-deep-recon/SKILL.md | 6 +-- .../bmad-deep-recon/references/run.md | 2 +- src/core-skills/bmad-forge-idea/SKILL.md | 10 ++--- src/core-skills/bmad-help/SKILL.md | 2 +- src/core-skills/bmad-party-mode/SKILL.md | 4 +- .../references/create-party.md | 2 +- .../references/party-memory.md | 2 +- src/core-skills/bmad-review/SKILL.md | 2 +- test/test-installation-components.js | 44 ++++++++++++++++++- 53 files changed, 130 insertions(+), 90 deletions(-) diff --git a/src/bmm-skills/agents/bmad-agent-analyst/SKILL.md b/src/bmm-skills/agents/bmad-agent-analyst/SKILL.md index a477421bed..daa959fc12 100644 --- a/src/bmm-skills/agents/bmad-agent-analyst/SKILL.md +++ b/src/bmm-skills/agents/bmad-agent-analyst/SKILL.md @@ -20,7 +20,7 @@ You are Mary, the Business Analyst. You bring deep expertise in market research, ### Step 1: Resolve the Agent Block -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key agent` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key agent` **If the script fails**, resolve the `agent` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver: diff --git a/src/bmm-skills/agents/bmad-agent-architect/SKILL.md b/src/bmm-skills/agents/bmad-agent-architect/SKILL.md index 74227ae705..23e190590e 100644 --- a/src/bmm-skills/agents/bmad-agent-architect/SKILL.md +++ b/src/bmm-skills/agents/bmad-agent-architect/SKILL.md @@ -20,7 +20,7 @@ You are Winston, the System Architect. You turn product requirements and UX into ### Step 1: Resolve the Agent Block -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key agent` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key agent` **If the script fails**, resolve the `agent` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver: diff --git a/src/bmm-skills/agents/bmad-agent-dev/SKILL.md b/src/bmm-skills/agents/bmad-agent-dev/SKILL.md index 1a4b2be2ff..5ebf1f36cb 100644 --- a/src/bmm-skills/agents/bmad-agent-dev/SKILL.md +++ b/src/bmm-skills/agents/bmad-agent-dev/SKILL.md @@ -20,7 +20,7 @@ You are Amelia, the Senior Software Engineer. You execute approved stories with ### Step 1: Resolve the Agent Block -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key agent` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key agent` **If the script fails**, resolve the `agent` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver: diff --git a/src/bmm-skills/agents/bmad-agent-pm/SKILL.md b/src/bmm-skills/agents/bmad-agent-pm/SKILL.md index 88a3b0abb4..3896df02d9 100644 --- a/src/bmm-skills/agents/bmad-agent-pm/SKILL.md +++ b/src/bmm-skills/agents/bmad-agent-pm/SKILL.md @@ -20,7 +20,7 @@ You are John, the Product Manager. You drive PRD creation through user interview ### Step 1: Resolve the Agent Block -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key agent` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key agent` **If the script fails**, resolve the `agent` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver: diff --git a/src/bmm-skills/agents/bmad-agent-ux-designer/SKILL.md b/src/bmm-skills/agents/bmad-agent-ux-designer/SKILL.md index b326b33e47..49e7f75f9e 100644 --- a/src/bmm-skills/agents/bmad-agent-ux-designer/SKILL.md +++ b/src/bmm-skills/agents/bmad-agent-ux-designer/SKILL.md @@ -20,7 +20,7 @@ You are Sally, the UX Designer. You translate user needs into interaction design ### Step 1: Resolve the Agent Block -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key agent` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key agent` **If the script fails**, resolve the `agent` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver: diff --git a/src/bmm-skills/plan/bmad-architecture/SKILL.md b/src/bmm-skills/plan/bmad-architecture/SKILL.md index 86e4d381e8..97e43222ba 100644 --- a/src/bmm-skills/plan/bmad-architecture/SKILL.md +++ b/src/bmm-skills/plan/bmad-architecture/SKILL.md @@ -36,8 +36,8 @@ The **memlog** (`.memlog.md`) is the run's working memory: every decision, const Writes go through the shared script (don't read the file back except on resume): -- `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field scope="…" --field purpose="…" --field altitude="…"` -- `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type --text "…"` +- `uv run --no-project {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field scope="…" --field purpose="…" --field altitude="…"` +- `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type --text "…"` ## Resolution rules @@ -50,8 +50,8 @@ Writes go through the shared script (don't read the file back except on resume): **Forwarded activation:** if a caller invoked you with a stated intent and pre-resolved customization fields, honor them verbatim — skip your own intent inference, use the supplied values for those named fields, and resolve only the remaining fields from your own `customize.toml`. -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` (on failure read `{skill-root}/customize.toml`, use defaults). Run `{workflow.activation_steps_prepend}`, then `{workflow.activation_steps_append}`. Hold `{workflow.persistent_facts}` as standing context — empty unless the user opted in — and consult `{workflow.external_sources}` on demand. -2. Resolve config: `uv run {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root}` (merges `_bmad/config.toml`, `_bmad/config.user.toml`, and the `_bmad/custom/` overrides). From the merged JSON resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{project_name}` (under `core`), `{planning_artifacts}` (under `modules.bmm`), and `{date}`; missing keys take neutral defaults, never block. +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` (on failure read `{skill-root}/customize.toml`, use defaults). Run `{workflow.activation_steps_prepend}`, then `{workflow.activation_steps_append}`. Hold `{workflow.persistent_facts}` as standing context — empty unless the user opted in — and consult `{workflow.external_sources}` on demand. +2. Resolve config: `uv run --no-project {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root}` (merges `_bmad/config.toml`, `_bmad/config.user.toml`, and the `_bmad/custom/` overrides). From the merged JSON resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{project_name}` (under `core`), `{planning_artifacts}` (under `modules.bmm`), and `{date}`; missing keys take neutral defaults, never block. 3. Headless (no interactive user) → follow `references/headless.md` for the whole run. Otherwise greet `{user_name}` in `{communication_language}`. Detect the intent from the conversation and input — **create** (the default), **update** an existing spine, or **validate** one (see those sections). If the real ask is requirements / UX / a capability contract / epic breakdown / an agent, invoke the `bmad-prd`, `bmad-ux`, `bmad-spec`, `bmad-create-epics-and-stories`, or `bmad-workflow-builder` (if the BMad Builder module is installed) skill instead. 4. If a run folder for this target already exists under `{workflow.spine_output_path}`, offer to resume from its memlog rather than restart. 5. Interactive create: offer the working mode in `{communication_language}` — **Coaching path** (default) or **Fast path** (see *How you work*) — before any drafting; default to Coaching unless the user asks for speed. diff --git a/src/bmm-skills/plan/bmad-create-epics-and-stories/SKILL.md b/src/bmm-skills/plan/bmad-create-epics-and-stories/SKILL.md index 54b8565028..3561c6e55a 100644 --- a/src/bmm-skills/plan/bmad-create-epics-and-stories/SKILL.md +++ b/src/bmm-skills/plan/bmad-create-epics-and-stories/SKILL.md @@ -51,7 +51,7 @@ This uses **step-file architecture** for disciplined execution: ### Step 1: Resolve the Workflow Block -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` **If the script fails**, resolve the `workflow` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver: diff --git a/src/bmm-skills/plan/bmad-create-epics-and-stories/steps/step-04-final-validation.md b/src/bmm-skills/plan/bmad-create-epics-and-stories/steps/step-04-final-validation.md index 86be03282c..71fbc05797 100644 --- a/src/bmm-skills/plan/bmad-create-epics-and-stories/steps/step-04-final-validation.md +++ b/src/bmm-skills/plan/bmad-create-epics-and-stories/steps/step-04-final-validation.md @@ -138,6 +138,6 @@ Upon Completion of task output: offer to answer any questions about the Epics an ## On Complete -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` If the resolved `workflow.on_complete` is non-empty, follow it as the final terminal instruction before exiting. diff --git a/src/bmm-skills/plan/bmad-prd/SKILL.md b/src/bmm-skills/plan/bmad-prd/SKILL.md index 9e8efb953f..f02d5025b4 100644 --- a/src/bmm-skills/plan/bmad-prd/SKILL.md +++ b/src/bmm-skills/plan/bmad-prd/SKILL.md @@ -11,13 +11,13 @@ You are a master facilitator and coach helping the user create, edit, or validat - Bare paths resolve from skill root; `{skill-root}` is this skill's install dir; `{project-root}` is the project working dir. - `{workflow.}` resolves to fields in `customize.toml`'s `[workflow]` table (overrides win per BMad merge rules). - `{doc_workspace}` is the bound run folder. -- **File roles.** `.memlog.md` is the run's canonical memory and audit trail — every decision, change, and override (including headless overrides) lands as one append-only line as the conversation unfolds. All writes go through the shared script, never by hand: `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type --text ""` (atomic; read it back only to resume or audit). The PRD is distilled toward it; whatever isn't logged is lost on resume. `addendum.md` preserves user-contributed depth that belongs in a downstream document (architecture, solution design, UX spec) or earned a place but does not fit the PRD itself — rejected-alternative rationale, options-considered matrices, mechanism/transport decisions, technical-how, in-depth personas, sizing data. Capture to the addendum *during* the conversation when the user volunteers such content — do not wait for finalize. Audit and override information never goes in the addendum. +- **File roles.** `.memlog.md` is the run's canonical memory and audit trail — every decision, change, and override (including headless overrides) lands as one append-only line as the conversation unfolds. All writes go through the shared script, never by hand: `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type --text ""` (atomic; read it back only to resume or audit). The PRD is distilled toward it; whatever isn't logged is lost on resume. `addendum.md` preserves user-contributed depth that belongs in a downstream document (architecture, solution design, UX spec) or earned a place but does not fit the PRD itself — rejected-alternative rationale, options-considered matrices, mechanism/transport decisions, technical-how, in-depth personas, sizing data. Capture to the addendum *during* the conversation when the user volunteers such content — do not wait for finalize. Audit and override information never goes in the addendum. ## On Activation **Forwarded activation:** if a caller invoked you with a stated intent and pre-resolved customization fields (e.g. the `bmad-create-prd` / `bmad-edit-prd` / `bmad-validate-prd` shims), honor them verbatim — skip your own intent inference, use the supplied values for those named fields, and resolve only the remaining fields from your own `customize.toml`. -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. 2. Run `{workflow.activation_steps_prepend}`. Treat `{workflow.persistent_facts}` as foundational context (entries prefixed `file:` are loaded). `{workflow.external_sources}` is an org-configured registry of internal tools (knowledge bases, MCP tools); consult them alongside generic web research on the same triggers, org tools preferred when their directive matches. Research itself fires during Discovery — see **Research subagents**. 3. Load `{project-root}/_bmad/bmm/config.yaml` (+ `config.user.yaml` if present). Resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{planning_artifacts}`, `{project_name}`, `{date}`. Missing keys → neutral defaults; never block. 4. If headless, follow `references/headless.md` for the whole run. Otherwise greet the user **by name** using `{user_name}` and **in their language** using `{communication_language}` — and stay in `{communication_language}` for every turn for the entire run, not just the greeting. In the greeting, let the user know that at any point they can invoke `bmad-party-mode` for multi-agent perspectives or `bmad-advanced-elicitation` for deeper exploration on a specific section. Then scan for misroute on the first message: if the signal points elsewhere (game → BMad GDS; express build → `bmad-build`; one-pager → `bmad-product-brief`; vet product idea → `bmad-prfaq`; agent skill or custom agent → `bmad-workflow-builder`), suggest they might want the other options before continuing. @@ -29,9 +29,9 @@ Activation is complete. If `activation_steps_prepend` or `activation_steps_appen ## Intent Modes -**Create.** Bind `{doc_workspace}` to `{workflow.prd_output_path}/{workflow.run_folder_pattern}/`. Write `prd.md` with YAML frontmatter (title, status, created, updated — initial `status: draft`), and seed the memlog with `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic=""` so subsequent decisions land in a known file. Tell the user the path. Run `## Discovery`, then `## Finalize`. +**Create.** Bind `{doc_workspace}` to `{workflow.prd_output_path}/{workflow.run_folder_pattern}/`. Write `prd.md` with YAML frontmatter (title, status, created, updated — initial `status: draft`), and seed the memlog with `uv run --no-project {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic=""` so subsequent decisions land in a known file. Tell the user the path. Run `## Discovery`, then `## Finalize`. -**Update.** Reconcile the PRD with a change signal. Source-extract against PRD, addendum, `.memlog.md`, and original inputs (extract, don't ingest). If `.memlog.md` is missing, init it with `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace}`, then spawn a one-time bootstrap subagent to reverse-engineer a thin log from the PRD (one `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type decision --text ""` per recovered decision) before continuing. Surface conflicts with prior decisions before applying. Then `## Finalize`. +**Update.** Reconcile the PRD with a change signal. Source-extract against PRD, addendum, `.memlog.md`, and original inputs (extract, don't ingest). If `.memlog.md` is missing, init it with `uv run --no-project {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace}`, then spawn a one-time bootstrap subagent to reverse-engineer a thin log from the PRD (one `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type decision --text ""` per recovered decision) before continuing. Surface conflicts with prior decisions before applying. Then `## Finalize`. **Validate** (or *analyze*). Critique without changing. Load `references/validate.md`. @@ -90,5 +90,5 @@ Tell the user the sequence in one sentence, then walk it. Polish goes last so it 4. **Triage open items.** All Open Questions, `[ASSUMPTION]` tags, `[NOTE FOR PM]` callouts. Phase-blockers (would make the PRD unsafe for UX/architecture/epics) surfaced one at a time and resolved; non-blockers deferred with owner + revisit condition logged via `memlog.py append`. If phase-blocker count is high, flag it. 5. **Polish.** Apply `{workflow.doc_standards}` to `prd.md` and `addendum.md` in declared order (structural passes before prose — prose should not polish soon-to-be-cut text). Parallelize across documents, sequential within. 6. **External handoffs.** Execute `{workflow.external_handoffs}`; surface returned URLs/IDs. Skip and flag unavailable tools. -7. **Close.** Set `prd.md` frontmatter `status: final` and `updated` to `{date}` so future invocations distinguish this PRD from in-progress drafts. Record finalization via `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type event --text "PRD finalized"`. Share artifact paths. Common next: `bmad-ux`, `bmad-architecture`, `bmad-create-epics-and-stories`; invoke `bmad-help` for authoritative routing. +7. **Close.** Set `prd.md` frontmatter `status: final` and `updated` to `{date}` so future invocations distinguish this PRD from in-progress drafts. Record finalization via `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type event --text "PRD finalized"`. Share artifact paths. Common next: `bmad-ux`, `bmad-architecture`, `bmad-create-epics-and-stories`; invoke `bmad-help` for authoritative routing. 8. Run `{workflow.on_complete}` if non-empty. diff --git a/src/bmm-skills/plan/bmad-prd/references/headless.md b/src/bmm-skills/plan/bmad-prd/references/headless.md index 2f5a168a0d..a0ed7e9f38 100644 --- a/src/bmm-skills/plan/bmad-prd/references/headless.md +++ b/src/bmm-skills/plan/bmad-prd/references/headless.md @@ -34,6 +34,6 @@ End with the JSON response (full schemas with examples in `assets/headless-schem ## Mode-specific overrides -**Update.** Apply the change, log it via `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type change --text ""`, and surface any conflict-with-prior-decision in `conflicts_with_prior_decisions[]` in the JSON status. Halt `blocked` if intent is ambiguous. +**Update.** Apply the change, log it via `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type change --text ""`, and surface any conflict-with-prior-decision in `conflicts_with_prior_decisions[]` in the JSON status. Halt `blocked` if intent is ambiguous. **Validate.** Always write both `validation-report.html` and `validation-report.md` to `{doc_workspace}` regardless of finding count. Always include `"offer_to_update": true` in the JSON status. Skip the browser-open step in `references/validate.md` — write the artifacts and return. diff --git a/src/bmm-skills/plan/bmad-prfaq/SKILL.md b/src/bmm-skills/plan/bmad-prfaq/SKILL.md index b0782fa02b..d0e00cbf87 100644 --- a/src/bmm-skills/plan/bmad-prfaq/SKILL.md +++ b/src/bmm-skills/plan/bmad-prfaq/SKILL.md @@ -30,7 +30,7 @@ The PRFAQ forces customer-first clarity: write the press release announcing the ### Step 1: Resolve the Workflow Block -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` **If the script fails**, resolve the `workflow` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver: diff --git a/src/bmm-skills/plan/bmad-prfaq/references/verdict.md b/src/bmm-skills/plan/bmad-prfaq/references/verdict.md index 7173b84e80..fcae764bd4 100644 --- a/src/bmm-skills/plan/bmad-prfaq/references/verdict.md +++ b/src/bmm-skills/plan/bmad-prfaq/references/verdict.md @@ -78,6 +78,6 @@ purpose: "Token-efficient context for downstream PRD creation" This is the terminal stage. If the user wants to revise, loop back to the relevant stage. Otherwise, the workflow is done. -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` If the resolved `workflow.on_complete` is non-empty, follow it as the final terminal instruction before exiting. diff --git a/src/bmm-skills/plan/bmad-product-brief/SKILL.md b/src/bmm-skills/plan/bmad-product-brief/SKILL.md index 86c05d3fd2..71d06d11df 100644 --- a/src/bmm-skills/plan/bmad-product-brief/SKILL.md +++ b/src/bmm-skills/plan/bmad-product-brief/SKILL.md @@ -15,7 +15,7 @@ At the opening greeting, let the user know they can invoke `bmad-party-mode` for ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. 2. Execute each entry in `{workflow.activation_steps_prepend}` in order. 3. Treat every entry in `{workflow.persistent_facts}` as foundational context for the rest of the run. Entries prefixed `file:` are paths or globs under `{project-root}` — load the referenced contents as facts. All other entries are facts verbatim. 4. `{workflow.external_sources}` is an org-configured registry of internal tools (knowledge bases, MCP tools); consult them alongside generic web research on the same triggers in `## Discovery`, org tools preferred when their directive matches. If a named tool is unavailable at runtime, fall back to standard behavior and note the gap when relevant. @@ -28,9 +28,9 @@ Activation is complete. If `activation_steps_prepend` or `activation_steps_appen ## Intent Operating Modes -**Create.** A brief the user is proud of, that meets their needs, drawn out through real conversation — do not assume: instead converse and understand, and then help craft the best product brief for their needs. Begin in `## Discovery` before drafting; the brief comes after the picture is on the table. Shape follows the product and need. Treat `{workflow.brief_template}` as a starting structure, not a contract: drop sections that do not earn their place, add sections the product needs, reorder freely - create sections for specialized domains or concerns also as needed. The brief serves the product's story, not the template's shape. Bind `{doc_workspace}` to a fresh folder at `{workflow.brief_output_path}/{workflow.run_folder_pattern}/`, write `brief.md` there with YAML frontmatter (title, status, created, updated), and seed the memlog: `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic=""`. For Update and Validate, `{doc_workspace}` is the existing folder of the brief being targeted. +**Create.** A brief the user is proud of, that meets their needs, drawn out through real conversation — do not assume: instead converse and understand, and then help craft the best product brief for their needs. Begin in `## Discovery` before drafting; the brief comes after the picture is on the table. Shape follows the product and need. Treat `{workflow.brief_template}` as a starting structure, not a contract: drop sections that do not earn their place, add sections the product needs, reorder freely - create sections for specialized domains or concerns also as needed. The brief serves the product's story, not the template's shape. Bind `{doc_workspace}` to a fresh folder at `{workflow.brief_output_path}/{workflow.run_folder_pattern}/`, write `brief.md` there with YAML frontmatter (title, status, created, updated), and seed the memlog: `uv run --no-project {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic=""`. For Update and Validate, `{doc_workspace}` is the existing folder of the brief being targeted. -**Update.** Reconcile an existing brief with a change signal. Before proposing changes, read the brief, addendum, `.memlog.md`, and original inputs — and run the `## Discovery` posture against the change signal (a patch applied without context becomes drift). If `.memlog.md` is missing (a legacy or pre-standard brief), init it with `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace}` first — this update is its first entry. Surface conflicts with prior decisions before changing. Headless override: log the reversal via `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type override --text ""`, then apply; halt `blocked` if intent is ambiguous. If the change is fundamental, offer Create instead of patching. +**Update.** Reconcile an existing brief with a change signal. Before proposing changes, read the brief, addendum, `.memlog.md`, and original inputs — and run the `## Discovery` posture against the change signal (a patch applied without context becomes drift). If `.memlog.md` is missing (a legacy or pre-standard brief), init it with `uv run --no-project {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace}` first — this update is its first entry. Surface conflicts with prior decisions before changing. Headless override: log the reversal via `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type override --text ""`, then apply; halt `blocked` if intent is ambiguous. If the change is fundamental, offer Create instead of patching. **Validate.** Honest critique against the brief's own purpose. Read the brief, the addendum if present, `.memlog.md`, and any original inputs first — a validation that ignores prior decisions, rejected ideas, or context the user supplied is shallow. Cite specific lines. Caveat what cannot be evaluated. Return inline — no separate file unless asked. Always offer to roll findings into an Update, even in headless mode — include `"offer_to_update": true` in the JSON status block. @@ -77,7 +77,7 @@ The workspace persists; stop and resume freely. The opener's philosophy (not in - **Right-size to purpose.** A passion project does not need investor-grade rigor. A VC pitch input does. Read the room. - **Persistence is real-time.** Once Create intent is confirmed, the workspace (run folder, `brief.md` skeleton with `status: draft`, `.memlog.md` seeded via `memlog.py init`) exists on disk and the user knows the path. -- **File roles.** `.memlog.md` is the run's canonical memory and audit trail — every decision, change, and override (including headless overrides) lands as one append-only line as the conversation unfolds. All writes go through the shared script, never by hand: `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type --text ""` (atomic; read it back only to resume or audit). The brief is distilled toward it; whatever isn't logged is lost on resume. `addendum.md` preserves user-contributed depth that belongs in a downstream document (PRD, architecture, solution design) or earned a place but does not fit the brief (rejected-alternative rationale, options-considered matrices, parked-roadmap context, technical constraints, in-depth personas, sizing data). Capture to the addendum *during* the conversation when the user volunteers such content — do not wait for finalize. Audit and override information never goes in the addendum. +- **File roles.** `.memlog.md` is the run's canonical memory and audit trail — every decision, change, and override (including headless overrides) lands as one append-only line as the conversation unfolds. All writes go through the shared script, never by hand: `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type --text ""` (atomic; read it back only to resume or audit). The brief is distilled toward it; whatever isn't logged is lost on resume. `addendum.md` preserves user-contributed depth that belongs in a downstream document (PRD, architecture, solution design) or earned a place but does not fit the brief (rejected-alternative rationale, options-considered matrices, parked-roadmap context, technical constraints, in-depth personas, sizing data). Capture to the addendum *during* the conversation when the user volunteers such content — do not wait for finalize. Audit and override information never goes in the addendum. - **Continuity across sessions.** If a prior in-progress draft for this project exists, the user is offered to resume. - **Extract, don't ingest.** Source artifacts (provided by the user or discovered during the run — transcripts, brainstorms, research reports, code, web results, prior briefs) enter the parent conversation as relevance-filtered extracts, not loaded wholesale. Subagents do the extraction against the user's stated focus; the parent context stays lean. - **Length and coherence.** Aim for 1-2 pages — if it is longer, the detail belongs in the addendum. Structure in service of the product; downstream consumers (PRD workflow, etc.) read this, so coherent shape matters. diff --git a/src/bmm-skills/plan/bmad-project-context/SKILL.md b/src/bmm-skills/plan/bmad-project-context/SKILL.md index 1f26d52341..062ff5eba2 100644 --- a/src/bmm-skills/plan/bmad-project-context/SKILL.md +++ b/src/bmm-skills/plan/bmad-project-context/SKILL.md @@ -19,8 +19,8 @@ Conversational always; the user approves every write. ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. Execute `{workflow.activation_steps_prepend}`; treat `{workflow.persistent_facts}` entries as standing context (`file:` = paths/globs to load, others verbatim). -2. Config: if `{project-root}/_bmad` exists, `uv run {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root}` and read `{user_name}`, `{communication_language}` (use it every turn), `{output_folder}`. Standalone: skip. +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. Execute `{workflow.activation_steps_prepend}`; treat `{workflow.persistent_facts}` entries as standing context (`file:` = paths/globs to load, others verbatim). +2. Config: if `{project-root}/_bmad` exists, `uv run --no-project {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root}` and read `{user_name}`, `{communication_language}` (use it every turn), `{output_folder}`. Standalone: skip. 3. **Load `references/best-practices.md` and `references/template.md` before anything else.** Every decision below is made against them. 4. Detect intent and greet `{user_name}`: **setup** (no instruction file in the target carries meaningful content — scaffolding alone, empty headings, a comment, a lone import line, is not meaningful; when unsure, adopt, since adopting a near-empty file costs one small ledger while setting up a meaningful one loses instructions), **adopt** (an instruction file has content but no managed block, whatever its state and whoever wrote it — the migration form of refresh; that file is the baseline and every instruction in it enters the ledger of step 1), **refresh** (a managed block exists), **record** (the user reports a mistake agents made), **audit** (re-verify and prune). A supplied intent that contradicts what detection finds — e.g. `setup` against a file with content — is surfaced and confirmed, never silently obeyed. Fold `{workflow.external_sources}` into the source list. Execute `{workflow.activation_steps_append}`. diff --git a/src/bmm-skills/plan/bmad-spec/SKILL.md b/src/bmm-skills/plan/bmad-spec/SKILL.md index 71c6500e12..fd07dbaff1 100644 --- a/src/bmm-skills/plan/bmad-spec/SKILL.md +++ b/src/bmm-skills/plan/bmad-spec/SKILL.md @@ -18,9 +18,9 @@ Multiple skills may call to update the same spec over time. ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly. +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly. 2. Run `{workflow.activation_steps_prepend}`. Treat `{workflow.persistent_facts}` as foundational context (`file:` entries are loaded). -3. Resolve config: `uv run {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root}` (merges `_bmad/config.toml`, `_bmad/config.user.toml`, and the `_bmad/custom/` overrides). From the merged JSON resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{project_name}`, `{output_folder}` (under `core`), and `{date}`. +3. Resolve config: `uv run --no-project {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root}` (merges `_bmad/config.toml`, `_bmad/config.user.toml`, and the `_bmad/custom/` overrides). From the merged JSON resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{project_name}`, `{output_folder}` (under `core`), and `{date}`. 4. Detect mode. **Headless** when any of: no TTY, programmatic caller (another skill or non-interactive runner), or the first message pre-supplies all inputs and asks for an artifact path back. **Interactive** otherwise. In interactive mode, greet by `{user_name}` in `{communication_language}`, stay in that language, and mention that `bmad-party-mode` and `bmad-advanced-elicitation` are available for deeper exploration on any field. Run `{workflow.activation_steps_append}`. @@ -58,8 +58,8 @@ Deriving the contract from a living log instead of editing the contract in place Writes go through the shared script — `{project-root}/_bmad/scripts/memlog.py`, the same location as `resolve_customization.py` (atomic; never read it back except to resume): -- `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {spec-folder} --field topic=""` — once, at create. -- `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {spec-folder} --type --text ""` — as each lands. +- `uv run --no-project {project-root}/_bmad/scripts/memlog.py init --workspace {spec-folder} --field topic=""` — once, at create. +- `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {spec-folder} --type --text ""` — as each lands. - Terminal moments (a validation verdict, "spec finalized") are `--type event` entries; the memlog carries no status field. ## The Operation diff --git a/src/bmm-skills/plan/bmad-sprint-planning/SKILL.md b/src/bmm-skills/plan/bmad-sprint-planning/SKILL.md index 999e20b52a..120ce49e7d 100644 --- a/src/bmm-skills/plan/bmad-sprint-planning/SKILL.md +++ b/src/bmm-skills/plan/bmad-sprint-planning/SKILL.md @@ -9,7 +9,7 @@ You are a senior developer about to commit to this plan. Two moves, in order: fi ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. 2. Execute each entry in `{workflow.activation_steps_prepend}` in order. 3. Treat every entry in `{workflow.persistent_facts}` as foundational context for the rest of the run. Entries prefixed `file:` are paths or globs under `{project-root}` — load the referenced contents as facts. All other entries are facts verbatim. 4. Load `{project-root}/_bmad/bmm/config.yaml` (and `config.user.yaml` if present). Resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{project_name}`, `{planning_artifacts}`, `{implementation_artifacts}`, `{project_knowledge}` (skip gracefully if unset), `{date}`. Stay in `{communication_language}` for every turn, not just the greeting. diff --git a/src/bmm-skills/plan/bmad-ux/SKILL.md b/src/bmm-skills/plan/bmad-ux/SKILL.md index bba3eedf5e..9e01183823 100644 --- a/src/bmm-skills/plan/bmad-ux/SKILL.md +++ b/src/bmm-skills/plan/bmad-ux/SKILL.md @@ -30,7 +30,7 @@ UX may lead, follow, or stand alone. Inherit `sources:` by reference; the spines ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. 2. Run `{workflow.activation_steps_prepend}`. Treat `{workflow.persistent_facts}` as foundational context (entries prefixed `file:` are loaded). `{workflow.external_sources}` is an org-configured registry of internal tools; consult them alongside generic web research on the same triggers, org tools preferred when their directive matches. 3. Load `{project-root}/_bmad/bmm/config.yaml` (+ `config.user.yaml` if present). Resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{planning_artifacts}`, `{project_name}`, `{date}`. Missing keys → neutral defaults; never block. 4. If headless, follow `references/headless.md` for the whole run. Otherwise greet the user **by name** using `{user_name}` and **in their language** using `{communication_language}` — and stay in `{communication_language}` for every turn. In the greeting, let the user know `bmad-party-mode` and `bmad-advanced-elicitation` are always available. Then scan for misroute on the first message: PRD → `bmad-prd`; architecture → `bmad-architecture`; game UX → BMad GDS; agent/skill → `bmad-workflow-builder`; brief → `bmad-product-brief`. @@ -42,15 +42,15 @@ Activation is complete. If `activation_steps_prepend` or `activation_steps_appen ## Modes -**Create.** Bind `{doc_workspace}` to `{workflow.ux_output_path}/{workflow.run_folder_pattern}/`. Create `.working/` and `imports/`; seed the memlog with `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic=""`; create `DESIGN.md` (frontmatter only) and `EXPERIENCE.md` (frontmatter only). Run Discovery → Finalize. +**Create.** Bind `{doc_workspace}` to `{workflow.ux_output_path}/{workflow.run_folder_pattern}/`. Create `.working/` and `imports/`; seed the memlog with `uv run --no-project {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic=""`; create `DESIGN.md` (frontmatter only) and `EXPERIENCE.md` (frontmatter only). Run Discovery → Finalize. -**Update.** Read spines + memlog + sources. If `.memlog.md` is missing, init it with `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace}` — this update is entry one. Surface conflicts with prior decisions. Run Finalize. +**Update.** Read spines + memlog + sources. If `.memlog.md` is missing, init it with `uv run --no-project {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace}` — this update is entry one. Surface conflicts with prior decisions. Run Finalize. **Validate.** See `references/validate.md`. ## Discovery -**Capture; do not author.** The spines are distilled at Finalize toward the memlog. Decisions → `.memlog.md` (canonical), each appended via `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type --text "…"` — never hand-edited; a resume reloads it. Creative-tool artifacts → `.working/`. User-supplied visuals (Figma, sketches, brand decks, image folders) → `imports/`, one `memlog.py append` per item. Spines win on conflict. +**Capture; do not author.** The spines are distilled at Finalize toward the memlog. Decisions → `.memlog.md` (canonical), each appended via `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type --text "…"` — never hand-edited; a resume reloads it. Creative-tool artifacts → `.working/`. User-supplied visuals (Figma, sketches, brand decks, image folders) → `imports/`, one `memlog.py append` per item. Spines win on conflict. **Source scan.** Glob `{planning_artifacts}/` for candidate input paths; surface paths only — never read content in the parent. User confirms which apply or adds others; subagent-extracts on confirm. @@ -87,4 +87,4 @@ Outcomes, in order: - **Key-screen mocks rendered.** Key-screens tool → `.working/` for surfaces where layout drives behavior or anchors visual language. - **Mock coverage confirmed.** Walk every IA surface; classify *mocked* vs *spine-only*. Ask: *"These will be built from spine tables alone — any need a visual reference?"* Render more if named; log spine-only choices. - **Layout extracted, artifacts promoted.** Distill subagent re-reads each `.working/` and `imports/` artifact; lifts visual decisions into DESIGN.md and behavioral decisions into EXPERIENCE.md. Promote `.working/` keepers to `mockups/` (HTML) or `wireframes/` (Excalidraw); imports stay. Inline relative links at relevant spine sections; state spines-win-on-conflict once. -- **Polished, handed off, closed.** Apply `{workflow.doc_standards}` in order. Execute `{workflow.external_handoffs}`; surface URLs. Set both files' `status: final`, `updated: {date}`. Log finalization via `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type event --text "spines finalized"`. Share paths. Common next: `bmad-architecture`, `bmad-create-epics-and-stories`, `bmad-build`. Run `{workflow.on_complete}`. +- **Polished, handed off, closed.** Apply `{workflow.doc_standards}` in order. Execute `{workflow.external_handoffs}`; surface URLs. Set both files' `status: final`, `updated: {date}`. Log finalization via `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type event --text "spines finalized"`. Share paths. Common next: `bmad-architecture`, `bmad-create-epics-and-stories`, `bmad-build`. Run `{workflow.on_complete}`. diff --git a/src/bmm-skills/plan/bmad-ux/references/headless.md b/src/bmm-skills/plan/bmad-ux/references/headless.md index 7f1f8588c6..2179c93a6c 100644 --- a/src/bmm-skills/plan/bmad-ux/references/headless.md +++ b/src/bmm-skills/plan/bmad-ux/references/headless.md @@ -32,6 +32,6 @@ End with JSON matching `assets/headless-schemas.md`. `intent` reflects detected ## Mode-specific overrides -**Update.** Apply the change. Log it via `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type change --text ""`. Surface conflicts in `conflicts_with_prior_decisions[]`. +**Update.** Apply the change. Log it via `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type change --text ""`. Surface conflicts in `conflicts_with_prior_decisions[]`. **Validate.** Always write both `validation-report.html` and `validation-report.md` regardless of finding count. Always include `"offer_to_update": true`. Skip the browser-open step. diff --git a/src/bmm-skills/ship/bmad-build-auto/SKILL.md b/src/bmm-skills/ship/bmad-build-auto/SKILL.md index f2500c218a..8b36d41d50 100644 --- a/src/bmm-skills/ship/bmad-build-auto/SKILL.md +++ b/src/bmm-skills/ship/bmad-build-auto/SKILL.md @@ -6,7 +6,7 @@ description: 'One iteration of an unattended development loop. Use when invoked Run the following command exactly once without changing the current working directory. Replace `{project-root}` with the absolute path to the project root and `{skill-root}` with the absolute path to this skill's directory: ```bash -uv run --no-cache "{project-root}/_bmad/scripts/render_skill.py" --project-root "{project-root}" --skill "{skill-root}" +uv run --no-project --no-cache "{project-root}/_bmad/scripts/render_skill.py" --project-root "{project-root}" --skill "{skill-root}" ``` - On success, read and follow the one absolute `workflow.md` instruction printed to stdout. diff --git a/src/bmm-skills/ship/bmad-build/SKILL.md b/src/bmm-skills/ship/bmad-build/SKILL.md index 100dd991ac..fcd32af1a6 100644 --- a/src/bmm-skills/ship/bmad-build/SKILL.md +++ b/src/bmm-skills/ship/bmad-build/SKILL.md @@ -6,7 +6,7 @@ description: 'Turns implementation work into working code, reviewed and verified Run the following command exactly once without changing the current working directory. Replace `{project-root}` with the absolute path to the project root and `{skill-root}` with the absolute path to this skill's directory: ```bash -uv run --no-cache "{project-root}/_bmad/scripts/render_skill.py" --project-root "{project-root}" --skill "{skill-root}" +uv run --no-project --no-cache "{project-root}/_bmad/scripts/render_skill.py" --project-root "{project-root}" --skill "{skill-root}" ``` - On success, read and follow the one absolute `workflow.md` instruction printed to stdout. diff --git a/src/bmm-skills/ship/bmad-code-review/SKILL.md b/src/bmm-skills/ship/bmad-code-review/SKILL.md index 8908c3ecaf..befc7c8d45 100644 --- a/src/bmm-skills/ship/bmad-code-review/SKILL.md +++ b/src/bmm-skills/ship/bmad-code-review/SKILL.md @@ -21,7 +21,7 @@ If you need an explicit user instruction to run them, ask once now for the whole ### Step 1: Resolve the Workflow Block -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` **If the script fails**, resolve the `workflow` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver: diff --git a/src/bmm-skills/ship/bmad-code-review/steps/step-04-present.md b/src/bmm-skills/ship/bmad-code-review/steps/step-04-present.md index 12561c3601..88ad156eea 100644 --- a/src/bmm-skills/ship/bmad-code-review/steps/step-04-present.md +++ b/src/bmm-skills/ship/bmad-code-review/steps/step-04-present.md @@ -129,6 +129,6 @@ Present the user with follow-up options: ## On Complete -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` If the resolved `workflow.on_complete` is non-empty, follow it as the final terminal instruction before exiting. diff --git a/src/bmm-skills/ship/bmad-correct-course/SKILL.md b/src/bmm-skills/ship/bmad-correct-course/SKILL.md index d5ca444342..4a9e217b2b 100644 --- a/src/bmm-skills/ship/bmad-correct-course/SKILL.md +++ b/src/bmm-skills/ship/bmad-correct-course/SKILL.md @@ -20,7 +20,7 @@ description: 'Assess the impact of a significant change during sprint execution ### Step 1: Resolve the Workflow Block -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` **If the script fails**, resolve the `workflow` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver: @@ -302,7 +302,7 @@ Activation is complete. If `activation_steps_prepend` or `activation_steps_appen Report workflow completion to user with personalized message: "Correct Course workflow complete, {user_name}!" Remind user of success criteria and next steps for Developer agent -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` — if the resolved value is non-empty, follow it as the final terminal instruction before exiting. +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` — if the resolved value is non-empty, follow it as the final terminal instruction before exiting. diff --git a/src/bmm-skills/ship/bmad-qa-generate-e2e-tests/SKILL.md b/src/bmm-skills/ship/bmad-qa-generate-e2e-tests/SKILL.md index 4286ca62f2..dd9e1ab48f 100644 --- a/src/bmm-skills/ship/bmad-qa-generate-e2e-tests/SKILL.md +++ b/src/bmm-skills/ship/bmad-qa-generate-e2e-tests/SKILL.md @@ -20,7 +20,7 @@ description: 'Generate automated API and end-to-end tests for implemented featur ### Step 1: Resolve the Workflow Block -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` **If the script fails**, resolve the `workflow` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver: @@ -171,6 +171,6 @@ Save summary to: `{default_output_file}` ## On Complete -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` If the resolved `workflow.on_complete` is non-empty, follow it as the final terminal instruction before exiting. diff --git a/src/bmm-skills/ship/bmad-retrospective/SKILL.md b/src/bmm-skills/ship/bmad-retrospective/SKILL.md index 4e830c45a7..a60b51cb5a 100644 --- a/src/bmm-skills/ship/bmad-retrospective/SKILL.md +++ b/src/bmm-skills/ship/bmad-retrospective/SKILL.md @@ -25,7 +25,7 @@ For automation, `-H ` — an explicit epic in headless mode — is the sta Run these in order before the retrospective begins: -1. **Resolve the workflow block.** Run `uv run --no-cache {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. If it fails, resolve `{workflow.*}` yourself by reading `{skill-root}/customize.toml`, then `{project-root}/_bmad/custom/{skill-name}.toml`, then `.user.toml` in that order, merging base → team → user (scalars override, keyed arrays-of-tables merge by `code`/`id`, other arrays append). +1. **Resolve the workflow block.** Run `uv run --no-project --no-cache {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. If it fails, resolve `{workflow.*}` yourself by reading `{skill-root}/customize.toml`, then `{project-root}/_bmad/custom/{skill-name}.toml`, then `.user.toml` in that order, merging base → team → user (scalars override, keyed arrays-of-tables merge by `code`/`id`, other arrays append). 2. **Run prepend steps** — execute each entry in `{workflow.activation_steps_prepend}` in order. 3. **Load persistent facts** — treat every `{workflow.persistent_facts}` entry as standing context. `file:` entries are paths/globs under `{project-root}` whose contents load as facts; all others are literal facts. 4. **Load config** from `{project-root}/_bmad/bmm/config.yaml`: `project_name`, `user_name`, `communication_language`, `document_output_language`, `user_skill_level`, `planning_artifacts`, `implementation_artifacts`, and `date` (system datetime), plus `output_folder` from `{project-root}/_bmad/core/config.yaml`. Speak all output in `{communication_language}`; write all documents in `{document_output_language}`. Never state time estimates — AI has changed development speed, so hour/day/week predictions are noise. diff --git a/src/bmm-skills/ship/bmad-walkthrough/SKILL.md b/src/bmm-skills/ship/bmad-walkthrough/SKILL.md index 823ed53095..343ca3e66c 100644 --- a/src/bmm-skills/ship/bmad-walkthrough/SKILL.md +++ b/src/bmm-skills/ship/bmad-walkthrough/SKILL.md @@ -20,7 +20,7 @@ description: 'Walk the user through reviewing a change: what it is for, what to ### Step 1: Resolve the Workflow Block -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` **If the script fails**, resolve the `workflow` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver: diff --git a/src/bmm-skills/ship/bmad-walkthrough/step-05-wrapup.md b/src/bmm-skills/ship/bmad-walkthrough/step-05-wrapup.md index 7cdb031052..43fec17c8d 100644 --- a/src/bmm-skills/ship/bmad-walkthrough/step-05-wrapup.md +++ b/src/bmm-skills/ship/bmad-walkthrough/step-05-wrapup.md @@ -25,6 +25,6 @@ HALT — do not proceed until the user makes their choice. ## On Complete -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` If the resolved `workflow.on_complete` is non-empty, follow it as the final terminal instruction before exiting. diff --git a/src/bmm-skills/v6-shims/bmad-create-architecture/SKILL.md b/src/bmm-skills/v6-shims/bmad-create-architecture/SKILL.md index 6ebdc0c7fa..814d7ba488 100644 --- a/src/bmm-skills/v6-shims/bmad-create-architecture/SKILL.md +++ b/src/bmm-skills/v6-shims/bmad-create-architecture/SKILL.md @@ -11,7 +11,7 @@ This skill was consolidated into `bmad-architecture`. It is retained as a thin c ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-create-architecture.toml` and `bmad-create-architecture.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-create-architecture.toml` and `bmad-create-architecture.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). 2. Load `{project-root}/_bmad/bmm/config.yaml` (and `config.user.yaml` if present) to resolve `{user_name}` and `{communication_language}`. diff --git a/src/bmm-skills/v6-shims/bmad-create-prd/SKILL.md b/src/bmm-skills/v6-shims/bmad-create-prd/SKILL.md index 7c53489d8f..2868d5f341 100644 --- a/src/bmm-skills/v6-shims/bmad-create-prd/SKILL.md +++ b/src/bmm-skills/v6-shims/bmad-create-prd/SKILL.md @@ -11,7 +11,7 @@ This skill was consolidated into `bmad-prd`. It is retained as a thin compatibil ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-create-prd.toml` and `bmad-create-prd.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-create-prd.toml` and `bmad-create-prd.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). 2. Load `{project-root}/_bmad/bmm/config.yaml` (and `config.user.yaml` if present) to resolve `{user_name}` and `{communication_language}`. diff --git a/src/bmm-skills/v6-shims/bmad-create-story/SKILL.md b/src/bmm-skills/v6-shims/bmad-create-story/SKILL.md index 876dcfd72e..e9dec6199b 100644 --- a/src/bmm-skills/v6-shims/bmad-create-story/SKILL.md +++ b/src/bmm-skills/v6-shims/bmad-create-story/SKILL.md @@ -32,7 +32,7 @@ If you need an explicit user instruction to run them, ask once now for the whole ### Step 1: Resolve the Workflow Block -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` **If the script fails**, resolve the `workflow` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver: @@ -430,7 +430,7 @@ Activation is complete. If `activation_steps_prepend` or `activation_steps_appen **The developer now has everything needed for flawless implementation!** - Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` — if the resolved value is non-empty, follow it as the final terminal instruction before exiting. + Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` — if the resolved value is non-empty, follow it as the final terminal instruction before exiting. diff --git a/src/bmm-skills/v6-shims/bmad-dev-story/SKILL.md b/src/bmm-skills/v6-shims/bmad-dev-story/SKILL.md index 2a98989930..4745795cde 100644 --- a/src/bmm-skills/v6-shims/bmad-dev-story/SKILL.md +++ b/src/bmm-skills/v6-shims/bmad-dev-story/SKILL.md @@ -29,7 +29,7 @@ metadata: ### Step 1: Resolve the Workflow Block -Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` +Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` **If the script fails**, resolve the `workflow` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver: @@ -498,7 +498,7 @@ Activation is complete. If `activation_steps_prepend` or `activation_steps_appen Suggest checking {sprint_status} to see project progress Remain flexible - allow user to choose their own path or ask for other assistance - Run: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` — if the resolved value is non-empty, follow it as the final terminal instruction before exiting. + Run: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow.on_complete` — if the resolved value is non-empty, follow it as the final terminal instruction before exiting. diff --git a/src/bmm-skills/v6-shims/bmad-domain-research/SKILL.md b/src/bmm-skills/v6-shims/bmad-domain-research/SKILL.md index d5c1c83e57..45d0c70526 100644 --- a/src/bmm-skills/v6-shims/bmad-domain-research/SKILL.md +++ b/src/bmm-skills/v6-shims/bmad-domain-research/SKILL.md @@ -11,6 +11,6 @@ This skill was consolidated into `bmad-deep-recon`. It is retained as a thin com ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-domain-research.toml` and `bmad-domain-research.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-domain-research.toml` and `bmad-domain-research.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). 2. Emit a deprecation notice to the user (in their configured communication language): `bmad-domain-research` is deprecated and forwards to `bmad-deep-recon` with the domain type. To silence this notice and access the full new surface (draft/process/run modes, research types, verification levels, HTML briefing, handoffs), migrate `_bmad/custom/bmad-domain-research.toml` to `_bmad/custom/bmad-deep-recon.toml` and invoke `bmad-deep-recon` directly. 3. Invoke `bmad-deep-recon` with: **research type** `domain` (skip its type inference), the four legacy fields above as pre-resolved values, and the user's original input verbatim. `bmad-deep-recon` takes the workflow from here — do not execute any further steps in this shim. diff --git a/src/bmm-skills/v6-shims/bmad-edit-prd/SKILL.md b/src/bmm-skills/v6-shims/bmad-edit-prd/SKILL.md index 02377cc712..3fbb402598 100644 --- a/src/bmm-skills/v6-shims/bmad-edit-prd/SKILL.md +++ b/src/bmm-skills/v6-shims/bmad-edit-prd/SKILL.md @@ -11,7 +11,7 @@ This skill was consolidated into `bmad-prd`. It is retained as a thin compatibil ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-edit-prd.toml` and `bmad-edit-prd.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-edit-prd.toml` and `bmad-edit-prd.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). 2. Load `{project-root}/_bmad/bmm/config.yaml` (and `config.user.yaml` if present) to resolve `{user_name}` and `{communication_language}`. diff --git a/src/bmm-skills/v6-shims/bmad-market-research/SKILL.md b/src/bmm-skills/v6-shims/bmad-market-research/SKILL.md index 60351f2e62..19f57de64b 100644 --- a/src/bmm-skills/v6-shims/bmad-market-research/SKILL.md +++ b/src/bmm-skills/v6-shims/bmad-market-research/SKILL.md @@ -11,6 +11,6 @@ This skill was consolidated into `bmad-deep-recon`. It is retained as a thin com ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-market-research.toml` and `bmad-market-research.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-market-research.toml` and `bmad-market-research.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). 2. Emit a deprecation notice to the user (in their configured communication language): `bmad-market-research` is deprecated and forwards to `bmad-deep-recon` with the market type. To silence this notice and access the full new surface (draft/process/run modes, research types, verification levels, HTML briefing, handoffs), migrate `_bmad/custom/bmad-market-research.toml` to `_bmad/custom/bmad-deep-recon.toml` and invoke `bmad-deep-recon` directly. 3. Invoke `bmad-deep-recon` with: **research type** `market` (skip its type inference), the four legacy fields above as pre-resolved values, and the user's original input verbatim. `bmad-deep-recon` takes the workflow from here — do not execute any further steps in this shim. diff --git a/src/bmm-skills/v6-shims/bmad-sprint-status/SKILL.md b/src/bmm-skills/v6-shims/bmad-sprint-status/SKILL.md index 8b50871033..5786812c12 100644 --- a/src/bmm-skills/v6-shims/bmad-sprint-status/SKILL.md +++ b/src/bmm-skills/v6-shims/bmad-sprint-status/SKILL.md @@ -11,7 +11,7 @@ This skill was consolidated into `bmad-sprint-planning`, which now owns the whol ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-sprint-status.toml` and `bmad-sprint-status.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-sprint-status.toml` and `bmad-sprint-status.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). 2. Load `{project-root}/_bmad/bmm/config.yaml` (and `config.user.yaml` if present) to resolve `{user_name}` and `{communication_language}`. diff --git a/src/bmm-skills/v6-shims/bmad-technical-research/SKILL.md b/src/bmm-skills/v6-shims/bmad-technical-research/SKILL.md index 288ee0cf80..9d9b8766a7 100644 --- a/src/bmm-skills/v6-shims/bmad-technical-research/SKILL.md +++ b/src/bmm-skills/v6-shims/bmad-technical-research/SKILL.md @@ -11,6 +11,6 @@ This skill was consolidated into `bmad-deep-recon`. It is retained as a thin com ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-technical-research.toml` and `bmad-technical-research.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-technical-research.toml` and `bmad-technical-research.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). 2. Emit a deprecation notice to the user (in their configured communication language): `bmad-technical-research` is deprecated and forwards to `bmad-deep-recon` with the technical type. To silence this notice and access the full new surface (draft/process/run modes, research types, verification levels, HTML briefing, handoffs), migrate `_bmad/custom/bmad-technical-research.toml` to `_bmad/custom/bmad-deep-recon.toml` and invoke `bmad-deep-recon` directly. 3. Invoke `bmad-deep-recon` with: **research type** `technical` (skip its type inference), the four legacy fields above as pre-resolved values, and the user's original input verbatim. `bmad-deep-recon` takes the workflow from here — do not execute any further steps in this shim. diff --git a/src/bmm-skills/v6-shims/bmad-validate-prd/SKILL.md b/src/bmm-skills/v6-shims/bmad-validate-prd/SKILL.md index cac3b8a00a..552c4670e1 100644 --- a/src/bmm-skills/v6-shims/bmad-validate-prd/SKILL.md +++ b/src/bmm-skills/v6-shims/bmad-validate-prd/SKILL.md @@ -11,7 +11,7 @@ This skill was consolidated into `bmad-prd`. It is retained as a thin compatibil ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-validate-prd.toml` and `bmad-validate-prd.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. This picks up any `{project-root}/_bmad/custom/bmad-validate-prd.toml` and `bmad-validate-prd.user.toml` overrides for the legacy fields (`activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete`). 2. Load `{project-root}/_bmad/bmm/config.yaml` (and `config.user.yaml` if present) to resolve `{user_name}` and `{communication_language}`. diff --git a/src/core-skills/bmad-advanced-elicitation/SKILL.md b/src/core-skills/bmad-advanced-elicitation/SKILL.md index 028d3bd642..0c0607f477 100644 --- a/src/core-skills/bmad-advanced-elicitation/SKILL.md +++ b/src/core-skills/bmad-advanced-elicitation/SKILL.md @@ -14,7 +14,7 @@ You are BMad's shared refinement checkpoint: other skills invoke you at natural ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. 2. Hold every `{workflow.preferences}` entry for the whole session, fix the target, and serve the first menu. ## Serving the Catalog @@ -61,4 +61,4 @@ Use the method's description as its intent and its output_pattern as a flexible Never change the work unless the user accepts the proposal. If they reject it, drop the proposal entirely. Any other reply is instruction to follow. -When a method casts personas (round tables, panels, debates), reuse party members already in the session if party mode is active; otherwise resolve installed agents on demand via `uv run {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root} --key agents` (a four-layer merge of `_bmad/config.toml`, `config.user.toml`, and the two `_bmad/custom/` overrides; each entry keyed by agent code carries name, title, icon, description). If neither yields a fit, invent named viewpoints suited to the content. +When a method casts personas (round tables, panels, debates), reuse party members already in the session if party mode is active; otherwise resolve installed agents on demand via `uv run --no-project {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root} --key agents` (a four-layer merge of `_bmad/config.toml`, `config.user.toml`, and the two `_bmad/custom/` overrides; each entry keyed by agent code carries name, title, icon, description). If neither yields a fit, invent named viewpoints suited to the content. diff --git a/src/core-skills/bmad-brainstorming/SKILL.md b/src/core-skills/bmad-brainstorming/SKILL.md index a4141454a3..7332deadfd 100644 --- a/src/core-skills/bmad-brainstorming/SKILL.md +++ b/src/core-skills/bmad-brainstorming/SKILL.md @@ -18,9 +18,9 @@ The session runs in one of three stances, chosen by the user — set explicitly ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, use a subagent to read `{skill-root}/customize.toml` directly with defaults. +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, use a subagent to read `{skill-root}/customize.toml` directly with defaults. 2. Run each `{workflow.activation_steps_prepend}` entry. Treat each `{workflow.persistent_facts}` entry as foundational context (`file:`-prefixed entries are paths/globs under `{project-root}` — load their contents; others are facts verbatim). -3. Resolve central config: `uv run {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root} --key core` (merges `_bmad/config.toml`, `_bmad/config.user.toml`, and the `_bmad/custom/` overrides); from the merged JSON resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{output_folder}`, `{project_name}`; `{date}` is today. On failure or missing values → neutral defaults; never block. +3. Resolve central config: `uv run --no-project {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root} --key core` (merges `_bmad/config.toml`, `_bmad/config.user.toml`, and the `_bmad/custom/` overrides); from the merged JSON resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{output_folder}`, `{project_name}`; `{date}` is today. On failure or missing values → neutral defaults; never block. 4. **If launched headless** (a machine signal, not a human asking for output — `references/headless.md` lists them): load `references/headless.md` and follow it for the whole run; never load it otherwise. Outside headless, you generate ideas yourself only in autonomous mode (`references/mode-autonomous.md`) — never in facilitator or partner mode. 5. **Otherwise (interactive):** greet `{user_name}` in `{communication_language}` and stay in it. Note that `bmad-party-mode` and `bmad-advanced-elicitation` are available any time (mention only the ones installed; either may be absent). Glob `{workflow.output_dir}/*/.memlog.md`, read each frontmatter, and offer to resume any with `status` not `complete` (`## Resuming`) or start fresh (`## Run a Session`). @@ -36,9 +36,9 @@ These fight your defaults, in every mode; hold them deliberately. The stance you **The memlog** is the session's memory: the single source every output builds from, and the file a resume reloads. Whatever isn't in it is gone. Log every idea, decision, question, and bit of user direction — anything you'd regret losing if the window closed — one line each, the gist in the user's meaning, in time order; never edit or reorder. Skip your prompts and small talk. All writes to memlog are atomic and use the script `memlog.py` invoked as follows: -- `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic="" --field goal="" --field mode=""` — create it once topic, goal, and stance are known. -- `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type --text ""` — log one entry. `--type` ∈ `idea`/`insight`/`question`/`decision`/`direction`/`technique` (a switch: `--text "started "`); omit for a plain note. Add `--by user`/`--by coach` to mark authorship — **required in Creative Partner mode** (renders `(idea by user)`); skip it otherwise. -- `uv run {project-root}/_bmad/scripts/memlog.py set --workspace {doc_workspace} --key status --value complete` — flip status at wrap-up. +- `uv run --no-project {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic="" --field goal="" --field mode=""` — create it once topic, goal, and stance are known. +- `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type --text ""` — log one entry. `--type` ∈ `idea`/`insight`/`question`/`decision`/`direction`/`technique` (a switch: `--text "started "`); omit for a plain note. Add `--by user`/`--by coach` to mark authorship — **required in Creative Partner mode** (renders `(idea by user)`); skip it otherwise. +- `uv run --no-project {project-root}/_bmad/scripts/memlog.py set --workspace {doc_workspace} --key status --value complete` — flip status at wrap-up. ## Run a Session diff --git a/src/core-skills/bmad-brainstorming/references/converge.md b/src/core-skills/bmad-brainstorming/references/converge.md index ac1786e67e..45ac3cb3c5 100644 --- a/src/core-skills/bmad-brainstorming/references/converge.md +++ b/src/core-skills/bmad-brainstorming/references/converge.md @@ -17,7 +17,7 @@ Pick by what the decision needs: - **PMI (Plus / Minus / Interesting)** — when one strong candidate needs pressure-testing before commitment: list its pluses, minuses, and the merely-interesting, then judge. - **MoSCoW** — when scoping a build: sort into Must / Should / Could / Won't-this-time. -Log the surviving directions and the reasoning with `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type decision --text ""` (use `--by` in Creative Partner mode). Two or three convergence moves chained is fine (e.g. cluster → score the clusters); more than that is usually over-processing. +Log the surviving directions and the reasoning with `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type decision --text ""` (use `--by` in Creative Partner mode). Two or three convergence moves chained is fine (e.g. cluster → score the clusters); more than that is usually over-processing. ## Then finalize diff --git a/src/core-skills/bmad-brainstorming/references/finalize.md b/src/core-skills/bmad-brainstorming/references/finalize.md index 2a4b6d25f2..873206d2d7 100644 --- a/src/core-skills/bmad-brainstorming/references/finalize.md +++ b/src/core-skills/bmad-brainstorming/references/finalize.md @@ -9,7 +9,7 @@ In Facilitator mode this is the one place your own creative contribution is welc 1. **Hand them the mirror first.** Reflect a vivid sampling of *their* ideas back — deliberately include the odd, random, or buried ones from earlier, not just the recent obvious ones (in Creative Partner mode the `(... by user)` tags tell you which were theirs). Ask what they see now: conclusions, synergies, themes, the few that actually matter. Let them connect first; their own pattern-recognition is the point. 2. **Then add the connections they would miss.** Lean in creatively — not new raw ideas, but the non-obvious links: this idea from technique one quietly solves that tension from technique four; these three are one idea wearing three hats; this wildcard is the real breakthrough. -Record the insights and chosen directions with `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type insight --text ""`. **Then run `uv run {project-root}/_bmad/scripts/memlog.py set --workspace {doc_workspace} --key status --value complete`** — the session is done and must stop being offered for resume. Do this even if the user declines every artifact below. +Record the insights and chosen directions with `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type insight --text ""`. **Then run `uv run --no-project {project-root}/_bmad/scripts/memlog.py set --workspace {doc_workspace} --key status --value complete`** — the session is done and must stop being offered for resume. Do this even if the user declines every artifact below. ## Artifacts diff --git a/src/core-skills/bmad-brainstorming/references/headless.md b/src/core-skills/bmad-brainstorming/references/headless.md index 5da9a25b2d..ff0a9b895e 100644 --- a/src/core-skills/bmad-brainstorming/references/headless.md +++ b/src/core-skills/bmad-brainstorming/references/headless.md @@ -29,9 +29,9 @@ Free-form structured payload in the first message; provide what applies: ## Run -1. Bind `{doc_workspace}` and create the memlog with `uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic="" [--field goal=""]`. It remains the canonical source every artifact derives from. -2. Run the divergent session per **The inversion**, capturing each idea with `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type idea --text ""` as it lands, and marking each technique switch with `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type technique --text "started "`. -3. Synthesize: surface the conclusions, connections, and the few directions that matter; record them with `uv run {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type insight --text ""`, then run `uv run {project-root}/_bmad/scripts/memlog.py set --workspace {doc_workspace} --key status --value complete`. +1. Bind `{doc_workspace}` and create the memlog with `uv run --no-project {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic="" [--field goal=""]`. It remains the canonical source every artifact derives from. +2. Run the divergent session per **The inversion**, capturing each idea with `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type idea --text ""` as it lands, and marking each technique switch with `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type technique --text "started "`. +3. Synthesize: surface the conclusions, connections, and the few directions that matter; record them with `uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {doc_workspace} --type insight --text ""`, then run `uv run --no-project {project-root}/_bmad/scripts/memlog.py set --workspace {doc_workspace} --key status --value complete`. 4. Produce the requested artifacts from the log — `brainstorm.html` (the imaginative, self-contained, no-template report) and/or the succinct `brainstorm-intent.md` — the same artifacts `references/finalize.md` describes, delegating each to a subagent that reads the log as its sole source. (Headless produces the `artifacts` payload directly; it does not ask, unlike the interactive opt-in.) 5. Execute each entry in `{workflow.external_handoffs}` (capture returned URLs/IDs into the JSON `external_handoffs` array; skip and flag unavailable tools — local files always exist). Then run `{workflow.on_complete}` if non-empty. diff --git a/src/core-skills/bmad-brainstorming/references/mode-autonomous.md b/src/core-skills/bmad-brainstorming/references/mode-autonomous.md index 1013895200..c853b76127 100644 --- a/src/core-skills/bmad-brainstorming/references/mode-autonomous.md +++ b/src/core-skills/bmad-brainstorming/references/mode-autonomous.md @@ -5,6 +5,6 @@ The user handed you the topic and wants to see what you come up with on your own - **Run a real divergent session yourself.** If the user supplied techniques (e.g. a composed prompt pasted from the selector page), honor those first; otherwise pick and run techniques on your own (use `brain.py` as in `## Choosing Techniques`, but *you* choose — no menu for the user). Capture each idea to the memlog with `--type idea --by coach`, marking each technique switch with a `technique` entry, shifting the creative domain every ~10 ideas, aiming past 100. Push past the obvious. - **Don't pepper the user with questions** — this is your run. One quick confirm of topic and goal up front is plenty. - **When it's mined out, synthesize and produce the keepsake.** Go to `## Wrap-Up` (`references/finalize.md`): record the insights, mark the memlog complete, and **auto-generate the imaginative HTML keepsake — don't ask first; the keepsake is the result you promised to show them.** Offer the other artifacts (intent doc, etc.) after. -- **Then, because a human is here, offer to keep going together.** They may want to push an idea further or react to what you found — if so, switch into **Facilitator** or **Creative Partner** (load that frame), **record the switch in the memlog** so a resume restores the new stance — `uv run {project-root}/_bmad/scripts/memlog.py set --workspace {doc_workspace} --key mode --value ` — and continue from the same memlog. +- **Then, because a human is here, offer to keep going together.** They may want to push an idea further or react to what you found — if so, switch into **Facilitator** or **Creative Partner** (load that frame), **record the switch in the memlog** so a resume restores the new stance — `uv run --no-project {project-root}/_bmad/scripts/memlog.py set --workspace {doc_workspace} --key mode --value ` — and continue from the same memlog. This is the interactive sibling of headless mode (`references/headless.md`): the same self-generation, but a person is present to receive the output and may continue. headless is the no-human, returns-JSON runner; this one greets, presents, and hands off. diff --git a/src/core-skills/bmad-customize/SKILL.md b/src/core-skills/bmad-customize/SKILL.md index 0394e9d85e..b3c7f585c3 100644 --- a/src/core-skills/bmad-customize/SKILL.md +++ b/src/core-skills/bmad-customize/SKILL.md @@ -87,7 +87,7 @@ Default by character (policy → team, personal → user), confirm before writin 3. Write. Create `{project-root}/_bmad/custom/` if needed. 4. Verify: ``` - uv run {project-root}/_bmad/scripts/resolve_customization.py --skill --project-root {project-root} --key + uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill --project-root {project-root} --key ``` Show the merged output, point out the changed fields. diff --git a/src/core-skills/bmad-deep-recon/SKILL.md b/src/core-skills/bmad-deep-recon/SKILL.md index 354c301f79..233c53e904 100644 --- a/src/core-skills/bmad-deep-recon/SKILL.md +++ b/src/core-skills/bmad-deep-recon/SKILL.md @@ -23,7 +23,7 @@ Three services, freely combined — each detailed in its reference: **Draft** a - **A claim is a sentence with a source.** Publisher, publication date, access date. No naked numbers. - **Report what is real.** Thin public data is reported as thin, absence of evidence is a finding, and freshness is part of truth — each pack sets windows per claim class; a market size from three years ago is history, not fact. - **Fast by default.** Rigor is bought consciously through the knobs, never accreted through extra passes. One gate, light checkpoints, no ceremony. -- **The memlog is the process memory.** Every decision, source batch, load-bearing claim, plan change, and assumption is one append-only line, always through the script: `uv run {project-root}/_bmad/scripts/memlog.py` with `--type `. +- **The memlog is the process memory.** Every decision, source batch, load-bearing claim, plan change, and assumption is one append-only line, always through the script: `uv run --no-project {project-root}/_bmad/scripts/memlog.py` with `--type `. - Web access is required for Run. If unavailable, say so and offer Draft/Process — never fabricate research. ## Resolution rules @@ -37,8 +37,8 @@ Three services, freely combined — each detailed in its reference: **Draft** a **Forwarded activation:** if a caller invoked you with a stated intent, research type, or pre-resolved customization fields (the legacy research shims and Mary's menu do), honor them verbatim — skip your own inference for those values and resolve only the rest. -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` (on failure read `{skill-root}/customize.toml`, use defaults). Run `{workflow.activation_steps_prepend}`, then `{workflow.activation_steps_append}`. -2. Resolve config: `uv run {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root}`. From the merged JSON resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{project_name}`, `{output_folder}` (under `core`), `{planning_artifacts}` (under `modules.bmm`; absent on core-only installs → `{output_folder}`), and `{date}`; missing keys take neutral defaults, never block. +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` (on failure read `{skill-root}/customize.toml`, use defaults). Run `{workflow.activation_steps_prepend}`, then `{workflow.activation_steps_append}`. +2. Resolve config: `uv run --no-project {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root}`. From the merged JSON resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{project_name}`, `{output_folder}` (under `core`), `{planning_artifacts}` (under `modules.bmm`; absent on core-only installs → `{output_folder}`), and `{date}`; missing keys take neutral defaults, never block. 3. Headless (no interactive user) → see `## Headless Mode`. Otherwise greet `{user_name}` in `{communication_language}` — and stay in it every turn. 4. Detect the intent: **draft**, **process** (the user has or names a report), **run**, or lifecycle **refresh** / **deepen** on an existing run folder. When the ask is bare research with no verb ("research X for me"), open the floor first — invite the decision they're facing and anything they already have (briefs, links, a prior report) in one turn, then ask only what's missing — and put the choice up front, once: **Run** it here now, or **Draft** a prompt for a deep-research tool they subscribe to — often cheaper and a strong gatherer, with Process turning its output into the same artifact. State the trade honestly (tokens and minutes here vs. one manual round-trip there); their call, remembered for the session. 5. If a run folder for this topic already exists under `{workflow.research_output_path}`, offer to resume or extend it (a drafted brief awaiting its report, a report awaiting refresh) rather than start a duplicate. diff --git a/src/core-skills/bmad-deep-recon/references/run.md b/src/core-skills/bmad-deep-recon/references/run.md index 52b8976a35..fb85864a69 100644 --- a/src/core-skills/bmad-deep-recon/references/run.md +++ b/src/core-skills/bmad-deep-recon/references/run.md @@ -23,7 +23,7 @@ Three knobs bundled in a **preset**; any knob pins individually, and **what the The one hard stop, kept light: decision, type and pack-derived dimensions pruned to it, shape, the **decomposition topology** — *breadth-first* (independent sub-questions: assistants split the dimensions), *depth-first* (one question that needs several perspectives: assistants split by angle or methodology, not by dimension), or *straightforward* (a focused ask: one assistant, a handful of calls, no fan-out — never overinvest in a simple query) — knobs in force and where each came from, which search surfaces exist (harness web search; installed search-shaped MCP tools; `{workflow.external_sources}` — check, don't assume), whether to run the fan-out as a workflow when the harness offers orchestration and `{workflow.use_workflows}` allows, and an honest time estimate (a standard run is minutes; deep runs are tens of minutes and many times the tokens). -Present as a compact checklist, get approval, then: bind `{doc_workspace}` under `{workflow.research_output_path}` — expand the folder name with `uv run scripts/recon_kit.py slug "" --type --pattern "{workflow.run_folder_pattern}"` so the same topic always resolves to the same folder — seed `research.md` from `{workflow.research_template}`, init the memlog (`uv run {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic="" --field type="" --field decision="" --field preset=""`), log the approved plan as a `decision`, and tell the user the path. +Present as a compact checklist, get approval, then: bind `{doc_workspace}` under `{workflow.research_output_path}` — expand the folder name with `uv run scripts/recon_kit.py slug "" --type --pattern "{workflow.run_folder_pattern}"` so the same topic always resolves to the same folder — seed `research.md` from `{workflow.research_template}`, init the memlog (`uv run --no-project {project-root}/_bmad/scripts/memlog.py init --workspace {doc_workspace} --field topic="" --field type="" --field decision="" --field preset=""`), log the approved plan as a `decision`, and tell the user the path. Each dimension then runs in **rounds** — up to the resolved `max_depth` — and the report grows as material lands: the user watches the document build, not a spinner. Every digest is written to `{doc_workspace}/digests/` the moment it exists — one file per assistant per round (`-r-.md`), the digest shape below, raw enough to re-derive from. diff --git a/src/core-skills/bmad-forge-idea/SKILL.md b/src/core-skills/bmad-forge-idea/SKILL.md index 0b50ce72c3..10a9affb72 100644 --- a/src/core-skills/bmad-forge-idea/SKILL.md +++ b/src/core-skills/bmad-forge-idea/SKILL.md @@ -22,9 +22,9 @@ Lead by questioning, not lecturing. Ask one question at a time, press on weak po ## On Activation -1. Resolve customization: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly with defaults. Apply the resolved `{workflow.*}` values throughout. +1. Resolve customization: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly with defaults. Apply the resolved `{workflow.*}` values throughout. 2. Run each `{workflow.activation_steps_prepend}` entry; treat each `{workflow.persistent_facts}` entry as foundational context (`file:` entries load their contents, `skill:` names a skill to consult, others are facts verbatim). -3. Resolve central config: `uv run {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root} --key core`; from the merged JSON read `{user_name}`, `{communication_language}`, `{output_folder}`. On failure use neutral defaults; never block. Greet `{user_name}` in `{communication_language}` and stay in it. +3. Resolve central config: `uv run --no-project {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root} --key core`; from the merged JSON read `{user_name}`, `{communication_language}`, `{output_folder}`. On failure use neutral defaults; never block. Greet `{user_name}` in `{communication_language}` and stay in it. 4. Note whether a BMad persona is already active in this conversation — the user loaded one (e.g. the analyst, the storyteller) and invoked the forge from within it. If so, that persona leads the session, in voice, throughout. 5. Resume: glob `{workflow.forge_output_path}/**/.memlog.md` (recursive, so it still finds sessions when `run_folder_pattern` is overridden to nest paths) and read only each match's frontmatter to find any whose `status` is not `complete`. Offer to resume one — then read its full memlog once to rebuild state and continue append-only — or to start fresh. 6. Run each `{workflow.activation_steps_append}` entry. @@ -53,7 +53,7 @@ Tell the user they can say **"attack this"**, **"defend this"**, or **"switch ro ### Set up the session Derive a kebab-case `{slug}` for the idea and bind the session workspace `{workspace} = {workflow.forge_output_path}/{workflow.run_folder_pattern}` (the pattern fills with `{slug}`). Create the memlog once the goal is known: -`uv run {project-root}/_bmad/scripts/memlog.py init --workspace {workspace} --field idea="" --field goal=""` +`uv run --no-project {project-root}/_bmad/scripts/memlog.py init --workspace {workspace} --field idea="" --field goal=""` Tell the user the path; state is on disk now, so the session survives interruption. If init fails, don't abort — run the forge in-conversation and tell the user state won't persist this session. @@ -74,7 +74,7 @@ When a branch resolves, pause before moving on. Give the user a chance to raise Do not use agreement or praise to make the interaction smoother; they lower pressure and lead to shallower thinking. Agreement is allowed only when it helps the user think better. Praise is noise. Continued engagement and ego-stroking are not objectives. In attack mode, never agree with the idea until the user ends the mode. For each answer, either challenge the weak point or build on the strong point, whichever helps the user think better. Capture as you go — each decision, assumption, crack, kill, and locked idea, one bullet in the user's meaning: -`uv run {project-root}/_bmad/scripts/memlog.py append --workspace {workspace} --type --text ""` +`uv run --no-project {project-root}/_bmad/scripts/memlog.py append --workspace {workspace} --type --text ""` A `lock` is an idea the user hardens — settled, not to be reopened; locks are what `forged-idea.md` is distilled from. Don't read the memlog back except on resume. If the user raises a different branch, capture it and stay put — the loop and the stray insight both survive. ## The personas @@ -103,5 +103,5 @@ The session can end in three valid states: Always render `{workspace}/forge-report.html` as a self-contained HTML file the user can open, with inline CSS and an inline-SVG seal or stamp. Summarize the outcome, the locked decisions, what was rejected and why, and the weak points that survived scrutiny, in the user's meaning. Credit the personas and parties that pressure-tested the idea by name, icon, and voice. Render a prominent wax-seal-style or stamped outcome mark, matched to the result: `HARDENED`, an `Idea Death Certificate` stamped `KILLED` with the cause of death, or `CLARIFIED`. Tell the user the path. -Flip the status at the end: `uv run {project-root}/_bmad/scripts/memlog.py set --workspace {workspace} --key status --value complete`. +Flip the status at the end: `uv run --no-project {project-root}/_bmad/scripts/memlog.py set --workspace {workspace} --key status --value complete`. If `{workflow.on_complete}` is non-empty, run all instructions in order. diff --git a/src/core-skills/bmad-help/SKILL.md b/src/core-skills/bmad-help/SKILL.md index b14ad930bd..065755066d 100644 --- a/src/core-skills/bmad-help/SKILL.md +++ b/src/core-skills/bmad-help/SKILL.md @@ -23,7 +23,7 @@ When this skill completes, the user should: ## Data Sources - **Catalog**: `{project-root}/_bmad/_config/bmad-help.csv` — assembled manifest of all installed module skills -- **Config**: Run `uv run {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root}` and use the merged JSON to resolve `output-location` variables and read `core.communication_language` and `modules.bmm.project_knowledge`. The resolver merges `_bmad/config.toml`, `_bmad/config.user.toml`, `_bmad/custom/config.toml`, and `_bmad/custom/config.user.toml` in that order. +- **Config**: Run `uv run --no-project {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root}` and use the merged JSON to resolve `output-location` variables and read `core.communication_language` and `modules.bmm.project_knowledge`. The resolver merges `_bmad/config.toml`, `_bmad/config.user.toml`, `_bmad/custom/config.toml`, and `_bmad/custom/config.user.toml` in that order. - **Artifacts**: Files matching `outputs` patterns at resolved `output-location` paths reveal which steps are possibly completed; their content may also provide grounding context for recommendations - **Project knowledge**: If `project_knowledge` resolves to an existing path, read it for grounding context. Never fabricate project-specific details. - **Module docs**: Rows with `_meta` in the `skill` column carry a URL or path in `output-location` pointing to the module's documentation. Fetch and use these to answer general questions about that module. diff --git a/src/core-skills/bmad-party-mode/SKILL.md b/src/core-skills/bmad-party-mode/SKILL.md index 69ee35a69a..6bdebeffdc 100644 --- a/src/core-skills/bmad-party-mode/SKILL.md +++ b/src/core-skills/bmad-party-mode/SKILL.md @@ -16,8 +16,8 @@ Run a round-table where these agents talk to each other and to the user like rea ## On Activation -1. **Resolve customization:** `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. Then run each `{workflow.activation_steps_prepend}` entry, and hold each `{workflow.persistent_facts}` entry as session-long context (`file:`-prefixed = paths/globs whose contents load as facts; `skill:`-prefixed = a skill to consult; others = literal facts). -2. **Resolve core config:** `uv run {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root}`. From the merged JSON's `core` table: greet with `{user_name}`, speak in `{communication_language}`, and resolve `{output_folder}`; `{date}` is today's date. +1. **Resolve customization:** `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. Then run each `{workflow.activation_steps_prepend}` entry, and hold each `{workflow.persistent_facts}` entry as session-long context (`file:`-prefixed = paths/globs whose contents load as facts; `skill:`-prefixed = a skill to consult; others = literal facts). +2. **Resolve core config:** `uv run --no-project {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root}`. From the merged JSON's `core` table: greet with `{user_name}`, speak in `{communication_language}`, and resolve `{output_folder}`; `{date}` is today's date. 3. **Detect intent and route.** If they want to create or configure a saved party setup (invent a cast, add a persona, distill customer data into a focus-group panel, set a default, or edit an existing custom party), load `references/create-party.md` and follow it. Otherwise run a party — continue below. 4. **Resolve the roster:** `uv run {skill-root}/scripts/resolve_party.py --project-root {project-root} --skill {skill-root}`. It returns the active roster (`{workflow.default_party}` group if set, else the installed agents), the other group names, `party_mode`, `memory_enabled`, and any scene/`open_cast`. Apply them: `open` already in the scene and let it shape how the room behaves; cast `open_cast` rooms on the fly (whoever fits the moment, varying as the topic shifts); if `installed_agents_resolved` is false or codes come back `unresolved`, tell the user, carry on with what returned, and improvise. Overrides: an inline-named cast IS the roster for the session (conjure them, go straight in); `--party ` (alias `--group `) overrides the configured `default_party` (unknown id -> show the available names and ask); `--list-groups` for just the menu. Mid-session the same levers apply: switch rooms by re-running `resolve_party.py --party ` and carrying the thread over, or summon any collective member by name. 5. **Memory.** If `memory_enabled` (from `resolve_party.py`), follow `references/party-memory.md` for the whole run. diff --git a/src/core-skills/bmad-party-mode/references/create-party.md b/src/core-skills/bmad-party-mode/references/create-party.md index bf86a1dd5f..175d141964 100644 --- a/src/core-skills/bmad-party-mode/references/create-party.md +++ b/src/core-skills/bmad-party-mode/references/create-party.md @@ -30,7 +30,7 @@ Ask which they're after if it isn't obvious, then proceed. ## Editing an existing party -When the user wants to change a party that already exists (retune a member's persona, add someone to a group, swap the default), read the current state first so you change rather than clobber: `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` returns the merged `party_members`, `party_groups`, and `default_party`. Show the member or group being touched, capture only the delta with the user, and hand that sparse change to `bmad-customize` — it replaces a `party_members`/`party_groups` entry whose `code`/`id` matches and appends the rest, so an edit is just the changed entry, never a full rewrite. +When the user wants to change a party that already exists (retune a member's persona, add someone to a group, swap the default), read the current state first so you change rather than clobber: `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow` returns the merged `party_members`, `party_groups`, and `default_party`. Show the member or group being touched, capture only the delta with the user, and hand that sparse change to `bmad-customize` — it replaces a `party_members`/`party_groups` entry whose `code`/`id` matches and appends the rest, so an edit is just the changed entry, never a full rewrite. ## Keeping new faces from a session diff --git a/src/core-skills/bmad-party-mode/references/party-memory.md b/src/core-skills/bmad-party-mode/references/party-memory.md index 78244d2c6a..5a4b4b7897 100644 --- a/src/core-skills/bmad-party-mode/references/party-memory.md +++ b/src/core-skills/bmad-party-mode/references/party-memory.md @@ -34,7 +34,7 @@ When a character shows up who isn't in the party's roster — cast from an open- ## Write it ``` -uv run {project-root}/_bmad/scripts/memlog.py append \ +uv run --no-project {project-root}/_bmad/scripts/memlog.py append \ --workspace {workflow.memory_dir}/{active} \ --type \ --text "" diff --git a/src/core-skills/bmad-review/SKILL.md b/src/core-skills/bmad-review/SKILL.md index 8c704b256b..901225590e 100644 --- a/src/core-skills/bmad-review/SKILL.md +++ b/src/core-skills/bmad-review/SKILL.md @@ -25,7 +25,7 @@ The lens set is whatever `{workflow.lenses}` resolves to, not a fixed list — o ## Execution -1. **Resolve customization:** `uv run {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. **Forwarded activation:** if a caller invoked you with pre-resolved customization fields (e.g. the `bmad-editorial-review` shim), honor them verbatim for those named fields — they already carry the user's overrides — and resolve only the remaining fields from your own `customize.toml`. Then execute each `{workflow.activation_steps_prepend}` entry in order, hold `{workflow.persistent_facts}` as standing context for the session, and treat `{workflow.review_guidance}` entries as standing review directives for every lens. +1. **Resolve customization:** `uv run --no-project {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --project-root {project-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly and use defaults. **Forwarded activation:** if a caller invoked you with pre-resolved customization fields (e.g. the `bmad-editorial-review` shim), honor them verbatim for those named fields — they already carry the user's overrides — and resolve only the remaining fields from your own `customize.toml`. Then execute each `{workflow.activation_steps_prepend}` entry in order, hold `{workflow.persistent_facts}` as standing context for the session, and treat `{workflow.review_guidance}` entries as standing review directives for every lens. 2. **Load the content.** Stage it once as a file: when the content is a branch, uncommitted work, or a commit range, use the repository's version-control tooling to write the unified diff to a uniquely-named file in the system temp directory and take that file's absolute path as the content. A branch means its diff against the merge base with its base branch; uncommitted work includes untracked files. Stage `claims` to its own file the same way — it is input for one lens, staged separately precisely so the other lenses never see it. If the content is empty or cannot be decoded as text: when the caller expects the raw findings JSON array (e.g. the legacy edge-case forwarder), return `[{"location":"N/A","trigger_condition":"Input empty or undecodable","guard_snippet":"Provide valid content to review","potential_consequence":"Review skipped — no analysis performed"}]` (no `lens` field) and stop; otherwise say what's wrong and ask for reviewable content. Classify the content — diff, source file, function, or document — and whether it is **code** or **docs**; scope rules and lens applicability both depend on it. A document that defines behavior (spec, requirements, plan, story) is `docs` that a behavioral lens may still apply to; judge by `when`. 3. **Select lenses** from `{workflow.lenses}`. A lens with an empty `instruction` is disabled. If the user or caller named lenses, run exactly those only — `applies_to` and `when` do not filter an explicit request. Otherwise run every enabled lens whose `applies_to` covers the content class (`any` always covers) and whose `when` applies. 4. **Announce the plan** in one line before running anything: the content class, the lenses about to run, and — when any lens has `after` set — that it runs on top of the named lens's findings. Skip the announcement entirely when the caller pinned an exact output contract (the legacy forwarders that demand raw JSON or one exact line) — their contract covers everything you emit, not just the findings block. Then execute each `{workflow.activation_steps_append}` entry in order. diff --git a/test/test-installation-components.js b/test/test-installation-components.js index 3811bfde69..7812a0b2d7 100644 --- a/test/test-installation-components.js +++ b/test/test-installation-components.js @@ -3879,7 +3879,7 @@ async function runTests() { assert(await fs.pathExists(path.join(skill49, 'SKILL.md')), 'build-auto entry reaches installed skill surface'); const skillSource49 = await fs.readFile(path.join(skill49, 'SKILL.md'), 'utf8'); assert( - skillSource49.includes('uv run --no-cache "{project-root}/_bmad/scripts/render_skill.py"'), + skillSource49.includes('uv run --no-project --no-cache "{project-root}/_bmad/scripts/render_skill.py"'), 'build-auto avoids the user-level uv cache and lets script metadata select Python', ); assert(!skillSource49.includes('uv run --python'), 'build-auto does not pin an exact Python series'); @@ -3929,10 +3929,50 @@ async function runTests() { ].join('\n'), 'utf8', ); + assert( + sharedInvocation49.includes('uv run --no-project'), + 'build-auto does not let uv manage the project environment', + sharedInvocation49, + ); + const renderOptions49 = { encoding: 'utf8', timeout: 120_000 }; + const brownfieldFixtures49 = [ + ['uv', { 'pyproject.toml': '[project]\nname = "brownfield-uv"\nversion = "0.0.0"\n' }], + ['pipenv', { Pipfile: '[requires]\npython_version = "3.11"\n' }], + ]; + for (const [name49, files49] of brownfieldFixtures49) { + const fixture49 = path.join(root49, `brownfield-${name49}`); + await fs.ensureDir(path.join(fixture49, '.venv')); + await fs.writeFile(path.join(fixture49, '.venv', 'project-owner'), 'project-owned'); + for (const [file49, content49] of Object.entries(files49)) { + await fs.writeFile(path.join(fixture49, file49), content49); + } + await fs.copy(path.join(bmadDir49, 'config.toml'), path.join(fixture49, '_bmad', 'config.toml')); + const resolver49 = spawnSync( + 'uv', + [ + 'run', + '--no-project', + '--python', + '3.11', + path.join(scripts49, 'resolve_customization.py'), + '--project-root', + fixture49, + '--skill', + skill49, + '--key', + 'workflow', + ], + { ...renderOptions49, cwd: fixture49 }, + ); + assert(resolver49.status === 0, `${name49} brownfield resolver completes`, `${resolver49.stdout}${resolver49.stderr}`); + assert( + (await fs.readFile(path.join(fixture49, '.venv', 'project-owner'), 'utf8')) === 'project-owned', + `${name49} brownfield project environment remains untouched`, + ); + } // The harness pins the interpreter to keep this scratch run deterministic; the shipped // SKILL.md command must not pin one, and test/test-build-auto-renderer.js executes that // unpinned form verbatim for both skills. - const renderOptions49 = { encoding: 'utf8', timeout: 120_000 }; const render49 = spawnSync( 'uv', ['run', '--python', '3.11', path.join(scripts49, 'render_skill.py'), '--project-root', root49, '--skill', skill49],