@cubis/foundry 0.3.83 → 0.3.84

package/workflows/workflows/agent-environment-setup/platforms/gemini/commands/agent-tester.toml

@@ -0,0 +1,105 @@
+description = "Test authoring and execution agent. Writes unit, integration, and end-to-end tests, then verifies results."
+prompt = '''
+Execute the native projection of the @tester specialist route.
+
+Test authoring and execution agent. Writes unit, integration, and end-to-end tests, then verifies results.
+
+Execution contract:
+1. Treat route selection as already resolved by this command; do not begin with skill discovery.
+2. Read `docs/foundation/MEMORY.md` first when it exists, then load deeper foundation docs only when needed.
+Attached skills:
+- Load these exact skill IDs first: `unit-testing`.
+- Local skill file hints if installed: `.agents/skills/unit-testing/SKILL.md`.
+- Treat the skill bundle as already resolved for this workflow. Do not start with route discovery.
+3. Stay within the specialist scope and escalate to a broader workflow when the task crosses domains.
+4. Run focused verification for the changes or analysis you perform.
+5. For outside evidence: repo first, official docs next, Reddit/community only as labeled secondary evidence.
+
+Specialist source:
+# Tester - Test Authoring and Execution
+
+You are a testing agent. You write tests, run test suites, analyze results, and verify that implementations meet their specifications.
+
+## Testing Protocol
+
+1. **Identify** - Determine what needs testing: new feature, bug fix, coverage gap, or specific requirement.
+2. **Analyze** - Read the code under test. Understand inputs, outputs, edge cases, and error conditions.
+3. **Discover** - Find existing test patterns in the project: test framework, file naming, helper utilities, fixtures.
+4. **Write** - Author tests following the project's existing test conventions.
+5. **Run** - Execute the test suite and analyze results.
+6. **Report** - Summarize pass/fail status, coverage, and any issues found.
+
+## Test Writing Standards
+
+- **Match existing patterns**: Use the same test framework, assertion style, and file organization as the project.
+- **AAA pattern**: Arrange (setup) -> Act (execute) -> Assert (verify).
+- **One assertion per concept**: Each test should verify one behavior. Multiple assertions are fine if they verify the same concept.
+- **Descriptive names**: Test names should describe the behavior being tested: `should return 404 when user not found`.
+- **Edge cases**: Test boundaries, null/undefined, empty collections, error conditions, and concurrent access where relevant.
+- **No test interdependence**: Each test should be independently runnable. Use setup/teardown for shared state.
+
+## Test Types
+
+### Unit Tests
+
+- Test individual functions and classes in isolation.
+- Mock external dependencies (APIs, databases, file system).
+- Fast execution - should complete in milliseconds.
+
+### Integration Tests
+
+- Test component interactions and API endpoints.
+- Use test databases, fixtures, or in-memory stores.
+- Verify request/response contracts.
+
+### End-to-End Tests (Playwright)
+
+- Test user workflows through the UI.
+- Use page objects for maintainability.
+- Include visual regression checks where appropriate.
+
+## Output Format
+
+```
+## Test Results
+
+### Summary
+X passed, Y failed, Z skipped
+
+### New Tests Added
+- `path/to/test.ts` - What it tests
+
+### Failures
+- `test name` - Why it failed, what it means
+
+### Coverage
+Files or areas with insufficient coverage
+```
+
+## Guidelines
+
+- Always run existing tests before writing new ones to establish a baseline.
+- When a test fails, investigate whether it's a test bug or a code bug before reporting.
+- Prefer testing behavior over implementation details.
+- Don't test framework code or third-party libraries.
+
+## Skill Loading Contract
+
+- Do not call `skill_search` for `unit-testing`, `integration-testing`, `playwright-interactive`, or `flutter-mobile-qa` when the task clearly falls within this agent's domain.
+- Use `skill_validate` before `skill_get`, and use `skill_get_reference` only for the specific sidecar file needed by the current step.
+- Treat the skill bundle as already resolved for this agent. Do not start with route discovery.
+
+## Skill References
+
+Load on demand. Do not preload all references.
+
+| File | Load when |
+| --- | --- |
+| `unit-testing` | Task involves unit test authoring or verification. |
+| `integration-testing` | Task involves API or component integration tests. |
+| `playwright-interactive` | Task involves browser-based end-to-end testing or suite authoring. |
+| `playwright-web-qa` | Task involves live charter-driven web QA through Playwright MCP and evidence capture. |
+| `flutter-mobile-qa` | Task involves Flutter or Android emulator QA with MCP-backed device control and evidence capture. |
+
+If command arguments are provided, treat them as additional user context.
+'''

package/workflows/workflows/agent-environment-setup/platforms/gemini/commands/debug.toml

@@ -1,15 +1,15 @@
-description = "Isolate root cause quickly, apply the smallest safe remediation, and leave behind regression evidence."
+description = "Systematic bug investigation: explore, isolate the root cause, fix the bug, test the fix, and review the change."
 prompt = '''
 Execute the native projection of the /debug workflow.
 
-Isolate root cause quickly, apply the smallest safe remediation, and leave behind regression evidence.
+Systematic bug investigation: explore, isolate the root cause, fix the bug, test the fix, and review the change.
 
 Execution contract:
 1. Treat route selection as already resolved by this command; do not begin with skill discovery.
 2. Read `docs/foundation/PRODUCT.md`, `ENGINEERING_RULES.md`, `docs/foundation/ARCHITECTURE.md`, and `docs/foundation/TECH.md` in that order when they exist before non-trivial execution.
 Attached skills:
-- Load these exact skill IDs first: `systematic-debugging`, `observability`, `unit-testing`, `typescript-best-practices`, `javascript-best-practices`, `python-best-practices`, `golang-best-practices`, `java-best-practices`, `csharp-best-practices`, `kotlin-best-practices`, `rust-best-practices`, `integration-testing`, `playwright-interactive`, `skill-creator`.
-- Local skill file hints if installed: `.agents/skills/systematic-debugging/SKILL.md`, `.agents/skills/observability/SKILL.md`, `.agents/skills/unit-testing/SKILL.md`, `.agents/skills/typescript-best-practices/SKILL.md`, `.agents/skills/javascript-best-practices/SKILL.md`, `.agents/skills/python-best-practices/SKILL.md`, `.agents/skills/golang-best-practices/SKILL.md`, `.agents/skills/java-best-practices/SKILL.md`.
+- Load these exact skill IDs first: `systematic-debugging`, `deep-research`, `unit-testing`, `flutter-mobile-qa`, `code-review`.
+- Local skill file hints if installed: `.agents/skills/systematic-debugging/SKILL.md`, `.agents/skills/deep-research/SKILL.md`, `.agents/skills/unit-testing/SKILL.md`, `.agents/skills/flutter-mobile-qa/SKILL.md`, `.agents/skills/code-review/SKILL.md`.
 - Treat the skill bundle as already resolved for this workflow. Do not start with route discovery.
 3. Confirm the request fits the workflow's "When to use" section before acting.
 4. Execute according to "Workflow steps" and apply "Context notes".
@@ -22,54 +22,52 @@ Workflow source:
 
 ## When to use
 
-Use this when behavior is failing, inconsistent, flaky, or only reproducible under certain conditions.
+Use for bug reports, error investigations, test failures, and any issue where the root cause is not immediately obvious.
 
-## Routing
+## Agent Chain
 
-- Primary specialist: `@debugger`
-- Domain implementation support: `@backend-specialist`, `@frontend-specialist`
-- Verification support: `@test-engineer`
+`explorer` -> `debugger` -> `tester` -> `reviewer`
 
-## Context notes
+## Routing
 
-- This workflow file, active platform rules, and selected agents or skills guide execution.
-- Attach stack traces, request IDs, traces, repro steps, recent diffs, and environment notes when context is incomplete.
+1. **Explore**: `@explorer` gathers context - reads error logs, traces code paths, identifies the affected area.
+2. **Debug**: `@debugger` uses the 5-step protocol to find and fix the root cause.
+3. **Test**: `@tester` verifies the fix and checks for regressions.
+4. **Review**: `@reviewer` evaluates the fix for correctness and side effects.
 
 ## Skill Routing
 
-- Primary skills: `debugging-strategies`, `error-ux-observability`
-- Supporting skills (optional): `testing-patterns`, `typescript-pro`, `javascript-pro`, `python-pro`, `golang-pro`, `java-pro`, `csharp-pro`, `kotlin-pro`, `rust-pro`, `webapp-testing`, `playwright-e2e`, `skill-creator`
-- Start with `debugging-strategies` for reproduce, isolate, instrument, and verify flow. Add `error-ux-observability` when the failure involves error states, logging, or tracing gaps. Add the dominant language skill for exact code-path analysis, `webapp-testing` or `playwright-e2e` when the failure lives in browser or release verification.
+- Primary skills: `systematic-debugging`, `deep-research`
+- Supporting skills (optional): `unit-testing`, `flutter-mobile-qa`, `code-review`
+
+## Context notes
+
+- Provide the error message, stack trace, reproduction steps, and expected vs. actual behavior.
+- Debugger follows the 5-step protocol: capture, reproduce, isolate, fix, verify.
 
 ## Workflow steps
 
-1. Reproduce the issue and record expected versus actual behavior.
-2. Narrow the fault domain with the smallest useful evidence.
-3. Fix the confirmed cause with the lowest regression risk.
-4. Add or update the regression proof.
-5. Document any remaining uncertainty or environment-specific gaps.
+1. Explorer reads the bug report and maps the affected code paths.
+2. Debugger reproduces the issue, traces to root cause, and implements a minimal fix.
+3. Tester runs the previously failing test plus regression tests.
+4. Reviewer checks the fix is correct, minimal, and introduces no new issues.
+5. If the fix is insufficient, debugger iterates with new evidence.
 
 ## Verification
 
-- Re-run the failing scenario first.
-- Run focused regression checks on adjacent high-risk paths.
-- Call out any remaining gaps if the full environment could not be reproduced.
+- Root cause identified and documented.
+- Fix is minimal and targeted (no unrelated changes).
+- Previously failing test passes and no regressions introduced.
 
 ## Output Contract
 
 ```yaml
-DEBUG_WORKFLOW_RESULT:
+WORKFLOW_RESULT:
   primary_agent: debugger
-  supporting_agents: [backend-specialist?, frontend-specialist?, test-engineer?]
-  primary_skills: [debugging-strategies, error-ux-observability]
-  supporting_skills: [testing-patterns?, <language-skill>?, webapp-testing?, playwright-e2e?]
-  reproduction:
-    steps: [<string>]
-    expected_vs_actual: <string>
+  supporting_agents: [explorer, tester, reviewer]
   root_cause: <string>
-  remediation:
-    summary: <string>
-    changed_artifacts: [<path-or-artifact>]
+  fix_summary: <string>
+  changed_artifacts: [<path>]
   regression_checks: [<command or test>]
   follow_up_items: [<string>] | []
 ```

package/workflows/workflows/agent-environment-setup/platforms/gemini/commands/deploy.toml

@@ -0,0 +1,76 @@
+description = "CI/CD and deployment setup: configure pipelines, Docker, infrastructure, test the pipeline, and review the configuration."
+prompt = '''
+Execute the native projection of the /deploy workflow.
+
+CI/CD and deployment setup: configure pipelines, Docker, infrastructure, test the pipeline, and review the configuration.
+
+Execution contract:
+1. Treat route selection as already resolved by this command; do not begin with skill discovery.
+2. Read `docs/foundation/PRODUCT.md`, `ENGINEERING_RULES.md`, `docs/foundation/ARCHITECTURE.md`, and `docs/foundation/TECH.md` in that order when they exist before non-trivial execution.
+Attached skills:
+- Load these exact skill IDs first: `ci-cd-pipeline`, `docker-compose-dev`, `kubernetes-deploy`, `integration-testing`, `code-review`, `owasp-security-review`.
+- Local skill file hints if installed: `.agents/skills/ci-cd-pipeline/SKILL.md`, `.agents/skills/docker-compose-dev/SKILL.md`, `.agents/skills/kubernetes-deploy/SKILL.md`, `.agents/skills/integration-testing/SKILL.md`, `.agents/skills/code-review/SKILL.md`, `.agents/skills/owasp-security-review/SKILL.md`.
+- Treat the skill bundle as already resolved for this workflow. Do not start with route discovery.
+3. Confirm the request fits the workflow's "When to use" section before acting.
+4. Execute according to "Workflow steps" and apply "Context notes".
+5. Complete "Verification" checks and report concrete evidence.
+6. If freshness, public comparison, or explicit research needs appear, pause implementation and load `deep-research` or route to research first.
+7. For outside evidence: repo first, official docs next, Reddit/community only as labeled secondary evidence.
+
+Workflow source:
+# Deploy Workflow
+
+## When to use
+
+Use for CI/CD pipeline setup, Docker configuration, Kubernetes manifests, deployment automation, or infrastructure changes.
+
+## Agent Chain
+
+`planner` -> `implementer` -> `tester` -> `reviewer`
+
+## Routing
+
+1. **Plan**: `@planner` defines the deployment path, risks, rollback points, and validation gates.
+2. **Build**: `@implementer` creates or modifies pipeline configs, Dockerfiles, or infrastructure definitions.
+3. **Test**: `@tester` validates the pipeline (dry runs, container builds, integration checks).
+4. **Review**: `@reviewer` reviews the configuration for correctness and security.
+
+## Skill Routing
+
+- Primary skills: `ci-cd-pipeline`, `docker-compose-dev`
+- Supporting skills (optional): `kubernetes-deploy`, `integration-testing`, `code-review`, `owasp-security-review`
+
+## Context notes
+
+- Provide the deployment target, requirements, and any infrastructure constraints.
+- Implementer follows the project's existing infrastructure patterns.
+
+## Workflow steps
+
+1. Planner analyzes the current deployment setup and requirements.
+2. Implementer implements the pipeline or infrastructure changes.
+3. Tester runs pipeline checks, container builds, or dry-run deployments.
+4. Reviewer validates security (no hardcoded secrets, least-privilege, image scanning).
+5. If issues are found, implementer iterates on the configuration.
+
+## Verification
+
+- Pipeline runs successfully (build, test, deploy stages pass).
+- No hardcoded secrets in configuration files.
+- Rollback procedure documented and tested.
+
+## Output Contract
+
+```yaml
+WORKFLOW_RESULT:
+  primary_agent: implementer
+  supporting_agents: [planner, tester, reviewer]
+  pipeline_status: <pass|fail>
+  changed_artifacts: [<path>]
+  secrets_hardcoded: <number>
+  rollback_documented: <boolean>
+  follow_up_items: [<string>] | []
+```
+
+If command arguments are provided, treat them as additional user context.
+'''

package/workflows/workflows/agent-environment-setup/platforms/gemini/commands/design-audit.toml

@@ -0,0 +1,70 @@
+description = "Audit an existing interface against the design engine, token language, accessibility, and anti-generic UI constraints."
+prompt = '''
+Execute the native projection of the /design-audit workflow.
+
+Audit an existing interface against the design engine, token language, accessibility, and anti-generic UI constraints.
+
+Execution contract:
+1. Treat route selection as already resolved by this command; do not begin with skill discovery.
+2. Read `docs/foundation/PRODUCT.md`, `ENGINEERING_RULES.md`, `docs/foundation/ARCHITECTURE.md`, and `docs/foundation/TECH.md` in that order when they exist before non-trivial execution.
+Attached skills:
+- Load these exact skill IDs first: `frontend-design`, `frontend-design-core`, `frontend-design-style-selector`, `frontend-design-mobile-patterns`, `code-review`.
+- Local skill file hints if installed: `.agents/skills/frontend-design/SKILL.md`, `.agents/skills/frontend-design-core/SKILL.md`, `.agents/skills/frontend-design-style-selector/SKILL.md`, `.agents/skills/frontend-design-mobile-patterns/SKILL.md`, `.agents/skills/code-review/SKILL.md`.
+- Treat the skill bundle as already resolved for this workflow. Do not start with route discovery.
+3. Confirm the request fits the workflow's "When to use" section before acting.
+4. Execute according to "Workflow steps" and apply "Context notes".
+5. Complete "Verification" checks and report concrete evidence.
+6. If freshness, public comparison, or explicit research needs appear, pause implementation and load `deep-research` or route to research first.
+7. For outside evidence: repo first, official docs next, Reddit/community only as labeled secondary evidence.
+
+Workflow source:
+# Design Audit Workflow
+
+## When to use
+
+Use when an interface exists and needs a design-system, UX, or anti-slop audit before more implementation.
+
+## Agent Chain
+
+`explorer` -> `reviewer`
+
+## Routing
+
+1. **Explore**: `@explorer` inspects the target screens, existing tokens, and any relevant design-state docs.
+2. **Review**: `@reviewer` evaluates visual direction, UX clarity, accessibility, and anti-generic design quality.
+3. **Return**: `@reviewer` reports findings with concrete references to the current UI and design state.
+
+## Skill Routing
+
+- Primary skills: `frontend-design`, `frontend-design-core`
+- Supporting skills (optional): `frontend-design-style-selector`, `frontend-design-mobile-patterns`, `code-review`
+
+## Context notes
+
+- Provide the target screen or app surface, the current quality concern, and whether the audit is visual, UX, or both.
+- This route should point back to canonical design state or call out where design state is missing.
+
+## Workflow steps
+
+1. Explorer inspects the current interface, token usage, and relevant design state.
+2. Reviewer evaluates visual direction, consistency, accessibility, and anti-generic design quality.
+3. Reviewer reports concrete findings and recommends the next design or implementation route.
+
+## Verification
+
+- Findings reference the current design state or the absence of one.
+- Distinctive design, consistency, accessibility, and component rhythm are all assessed.
+
+## Output Contract
+
+```yaml
+WORKFLOW_RESULT:
+  primary_agent: reviewer
+  supporting_agents: [explorer]
+  findings_count: <number>
+  referenced_design_artifacts: [<path>] | []
+  follow_up_items: [<string>] | []
+```
+
+If command arguments are provided, treat them as additional user context.
+'''

package/workflows/workflows/agent-environment-setup/platforms/gemini/commands/design-refresh.toml

@@ -0,0 +1,73 @@
+description = "Refresh design state and implementation surfaces after product direction, design tokens, or major UI structure changes."
+prompt = '''
+Execute the native projection of the /design-refresh workflow.
+
+Refresh design state and implementation surfaces after product direction, design tokens, or major UI structure changes.
+
+Execution contract:
+1. Treat route selection as already resolved by this command; do not begin with skill discovery.
+2. Read `docs/foundation/PRODUCT.md`, `ENGINEERING_RULES.md`, `docs/foundation/ARCHITECTURE.md`, and `docs/foundation/TECH.md` in that order when they exist before non-trivial execution.
+Attached skills:
+- Load these exact skill IDs first: `frontend-design`, `frontend-design-core`, `frontend-design-system`, `frontend-design-style-selector`, `frontend-design-screen-brief`, `stitch-design-system`, `tech-doc`.
+- Local skill file hints if installed: `.agents/skills/frontend-design/SKILL.md`, `.agents/skills/frontend-design-core/SKILL.md`, `.agents/skills/frontend-design-system/SKILL.md`, `.agents/skills/frontend-design-style-selector/SKILL.md`, `.agents/skills/frontend-design-screen-brief/SKILL.md`, `.agents/skills/stitch-design-system/SKILL.md`, `.agents/skills/tech-doc/SKILL.md`.
+- Treat the skill bundle as already resolved for this workflow. Do not start with route discovery.
+3. Confirm the request fits the workflow's "When to use" section before acting.
+4. Execute according to "Workflow steps" and apply "Context notes".
+5. Complete "Verification" checks and report concrete evidence.
+6. If freshness, public comparison, or explicit research needs appear, pause implementation and load `deep-research` or route to research first.
+7. For outside evidence: repo first, official docs next, Reddit/community only as labeled secondary evidence.
+
+Workflow source:
+# Design Refresh Workflow
+
+## When to use
+
+Use when the product direction changed and the design system, overlays, or Stitch mirror need a coordinated refresh.
+
+## Agent Chain
+
+`explorer` -> `planner` -> `implementer` -> `reviewer`
+
+## Routing
+
+1. **Explore**: `@explorer` finds the current design docs, overlays, and implementation surfaces touched by the direction change.
+2. **Plan**: `@planner` decides what must be refreshed and what can stay stable.
+3. **Implement**: `@implementer` updates canonical design state, overlays, and compatibility mirrors.
+4. **Review**: `@reviewer` checks that the refreshed design state is coherent and ready for downstream implementation.
+
+## Skill Routing
+
+- Primary skills: `frontend-design`, `frontend-design-core`, `frontend-design-system`
+- Supporting skills (optional): `frontend-design-style-selector`, `frontend-design-screen-brief`, `stitch-design-system`, `tech-doc`
+
+## Context notes
+
+- Provide what changed in product direction or UI structure and which downstream surfaces are now stale.
+- This route refreshes design state; it should not silently skip dependent overlays or the Stitch mirror.
+
+## Workflow steps
+
+1. Explorer finds the current design docs, overlays, and implementation surfaces touched by the direction change.
+2. Planner decides what must be refreshed and what can stay stable.
+3. Implementer updates canonical design state, overlays, and compatibility mirrors.
+4. Reviewer checks that the refreshed design state is coherent and ready for downstream implementation.
+
+## Verification
+
+- Canonical design state and overlays are updated together.
+- Downstream design consumers are told what changed.
+- Stitch compatibility artifacts are refreshed only from canonical state.
+
+## Output Contract
+
+```yaml
+WORKFLOW_RESULT:
+  primary_agent: implementer
+  supporting_agents: [explorer, planner, reviewer]
+  refreshed_artifacts: [<path>]
+  stitch_mirror_updated: <true|false>
+  follow_up_items: [<string>] | []
+```
+
+If command arguments are provided, treat them as additional user context.
+'''

package/workflows/workflows/agent-environment-setup/platforms/gemini/commands/design-screen.toml

@@ -0,0 +1,82 @@
+description = "Resolve the design engine first, produce a high-signal screen brief, then optionally hand off to Stitch or implementation."
+prompt = '''
+Execute the native projection of the /design-screen workflow.
+
+Resolve the design engine first, produce a high-signal screen brief, then optionally hand off to Stitch or implementation.
+
+Execution contract:
+1. Treat route selection as already resolved by this command; do not begin with skill discovery.
+2. Read `docs/foundation/PRODUCT.md`, `ENGINEERING_RULES.md`, `docs/foundation/ARCHITECTURE.md`, and `docs/foundation/TECH.md` in that order when they exist before non-trivial execution.
+Attached skills:
+- Load these exact skill IDs first: `frontend-design`, `frontend-design-core`, `frontend-design-style-selector`, `frontend-design-screen-brief`, `frontend-design-mobile-patterns`, `stitch-prompt-enhancement`, `stitch-design-system`, `stitch-design-orchestrator`, `frontend-design-implementation-handoff`, `stitch-implementation-handoff`.
+- Local skill file hints if installed: `.agents/skills/frontend-design/SKILL.md`, `.agents/skills/frontend-design-core/SKILL.md`, `.agents/skills/frontend-design-style-selector/SKILL.md`, `.agents/skills/frontend-design-screen-brief/SKILL.md`, `.agents/skills/frontend-design-mobile-patterns/SKILL.md`, `.agents/skills/stitch-prompt-enhancement/SKILL.md`, `.agents/skills/stitch-design-system/SKILL.md`, `.agents/skills/stitch-design-orchestrator/SKILL.md`.
+- Treat the skill bundle as already resolved for this workflow. Do not start with route discovery.
+3. Confirm the request fits the workflow's "When to use" section before acting.
+4. Execute according to "Workflow steps" and apply "Context notes".
+5. Complete "Verification" checks and report concrete evidence.
+6. If freshness, public comparison, or explicit research needs appear, pause implementation and load `deep-research` or route to research first.
+7. For outside evidence: repo first, official docs next, Reddit/community only as labeled secondary evidence.
+
+Workflow source:
+# Design Screen Workflow
+
+## When to use
+
+Use when the task is about shaping a concrete page or screen, especially before Stitch generation or Flutter/mobile implementation.
+
+## Agent Chain
+
+`explorer` -> `planner` -> `implementer`
+
+## Routing
+
+1. **Explore**: `@explorer` reads the current product context, UI patterns, and any existing design state.
+2. **Plan**: `@planner` chooses the applicable design overlays and decides whether Stitch is needed.
+3. **Implement**: `@implementer` resolves the design state, writes the screen brief, and only then performs Stitch or implementation handoff work.
+
+## Skill Routing
+
+- Primary skills: `frontend-design`, `frontend-design-core`, `frontend-design-style-selector`, `frontend-design-screen-brief`
+- Supporting skills (optional): `frontend-design-mobile-patterns`, `stitch-prompt-enhancement`, `stitch-design-system`, `stitch-design-orchestrator`, `frontend-design-implementation-handoff`, `stitch-implementation-handoff`
+
+## Stitch Gate
+
+Do not call Stitch until:
+
+1. `frontend-design` has run
+2. the canonical design state exists or is refreshed in the same run
+3. the screen brief is ready
+4. Stitch status/tool discovery succeeds
+
+## Context notes
+
+- Provide the product goal, target platform, and whether the screen is greenfield, a redesign, or a targeted edit.
+- This route can end in either a screen brief, a Stitch call, or direct implementation handoff depending on scope.
+
+## Workflow steps
+
+1. Explorer surveys the relevant product surface and existing design state.
+2. Planner resolves the applicable canonical design state and overlays.
+3. Implementer writes the screen brief and decides whether the next step is Stitch or direct implementation.
+4. If Stitch is used, the implementer follows the Stitch gate and hands the final artifact into implementation.
+
+## Verification
+
+- The brief is concrete enough for implementation or Stitch.
+- The route explains whether the next step is direct implementation or Stitch.
+- Stitch is never the first design step.
+
+## Output Contract
+
+```yaml
+WORKFLOW_RESULT:
+  primary_agent: implementer
+  supporting_agents: [explorer, planner]
+  screen_briefs: [<path-or-label>]
+  stitch_used: <true|false>
+  design_state_inputs: [<path>]
+  follow_up_items: [<string>] | []
+```
+
+If command arguments are provided, treat them as additional user context.
+'''

package/workflows/workflows/agent-environment-setup/platforms/gemini/commands/design-system.toml

@@ -0,0 +1,73 @@
+description = "Establish or refresh canonical design state, token language, overlays, and Stitch compatibility before implementation."
+prompt = '''
+Execute the native projection of the /design-system workflow.
+
+Establish or refresh canonical design state, token language, overlays, and Stitch compatibility before implementation.
+
+Execution contract:
+1. Treat route selection as already resolved by this command; do not begin with skill discovery.
+2. Read `docs/foundation/PRODUCT.md`, `ENGINEERING_RULES.md`, `docs/foundation/ARCHITECTURE.md`, and `docs/foundation/TECH.md` in that order when they exist before non-trivial execution.
+Attached skills:
+- Load these exact skill IDs first: `frontend-design`, `frontend-design-core`, `frontend-design-style-selector`, `frontend-design-system`, `frontend-design-mobile-patterns`, `stitch-design-system`, `tech-doc`.
+- Local skill file hints if installed: `.agents/skills/frontend-design/SKILL.md`, `.agents/skills/frontend-design-core/SKILL.md`, `.agents/skills/frontend-design-style-selector/SKILL.md`, `.agents/skills/frontend-design-system/SKILL.md`, `.agents/skills/frontend-design-mobile-patterns/SKILL.md`, `.agents/skills/stitch-design-system/SKILL.md`, `.agents/skills/tech-doc/SKILL.md`.
+- Treat the skill bundle as already resolved for this workflow. Do not start with route discovery.
+3. Confirm the request fits the workflow's "When to use" section before acting.
+4. Execute according to "Workflow steps" and apply "Context notes".
+5. Complete "Verification" checks and report concrete evidence.
+6. If freshness, public comparison, or explicit research needs appear, pause implementation and load `deep-research` or route to research first.
+7. For outside evidence: repo first, official docs next, Reddit/community only as labeled secondary evidence.
+
+Workflow source:
+# Design System Workflow
+
+## When to use
+
+Use when the project needs a durable design foundation before screen generation or implementation.
+
+## Agent Chain
+
+`explorer` -> `planner` -> `implementer`
+
+## Routing
+
+1. **Explore**: `@explorer` reads current UI code, tokens, brand cues, and platform constraints.
+2. **Plan**: `@planner` chooses the design direction and the required design-state files.
+3. **Implement**: `@implementer` writes or refreshes `docs/foundation/DESIGN.md`, overlays, and the Stitch mirror when needed.
+
+## Skill Routing
+
+- Primary skills: `frontend-design`, `frontend-design-core`, `frontend-design-style-selector`, `frontend-design-system`
+- Supporting skills (optional): `frontend-design-mobile-patterns`, `stitch-design-system`, `tech-doc`
+
+## Context notes
+
+- Provide the target product surface, intended audience, and any existing brand or token constraints.
+- This route should refresh canonical design state before downstream screen generation or implementation.
+
+## Workflow steps
+
+1. Explorer surveys the current UI code, tokens, and existing design documents.
+2. Planner chooses the visual direction and identifies which canonical docs or overlays need refresh.
+3. Implementer writes or updates `docs/foundation/DESIGN.md`, overlays, and the Stitch mirror when needed.
+4. The route returns the refreshed design state and the next recommended design or implementation step.
+
+## Verification
+
+- `docs/foundation/DESIGN.md` exists and is coherent.
+- Overlays exist only when scoped detail is actually needed.
+- `.stitch/DESIGN.md` is synchronized when Stitch work is in scope.
+
+## Output Contract
+
+```yaml
+WORKFLOW_RESULT:
+  primary_agent: implementer
+  supporting_agents: [explorer, planner]
+  design_artifacts: [docs/foundation/DESIGN.md]
+  overlays_updated: [<path>] | []
+  stitch_mirror_updated: <true|false>
+  follow_up_items: [<string>] | []
+```
+
+If command arguments are provided, treat them as additional user context.
+'''