@cubis/foundry 0.3.81 → 0.3.83

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

@@ -1,19 +1,86 @@
 description = "Execute large work in milestones with explicit quality gates and status updates."
 prompt = '''
-Follow the /implement-track workflow from .gemini/workflows/implement-track.md.
+Execute the native projection of the /implement-track workflow.
+
+Execute large work in milestones with explicit quality gates and status updates.
 
 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: `system-design`, `api-design`, `database-design`, `typescript-best-practices`, `javascript-best-practices`, `python-best-practices`, `golang-best-practices`, `react`, `nextjs`.
-- Local skill file hints if installed: `.gemini/skills/system-design/SKILL.md`, `.gemini/skills/api-design/SKILL.md`, `.gemini/skills/database-design/SKILL.md`, `.gemini/skills/typescript-best-practices/SKILL.md`, `.gemini/skills/javascript-best-practices/SKILL.md`, `.gemini/skills/python-best-practices/SKILL.md`, `.gemini/skills/golang-best-practices/SKILL.md`, `.gemini/skills/react/SKILL.md`.
+- Local skill file hints if installed: `.agents/skills/system-design/SKILL.md`, `.agents/skills/api-design/SKILL.md`, `.agents/skills/database-design/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/react/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.
+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 the researcher posture first.
+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:
+# Implement Track Workflow
+
+## When to use
+
+Use this for large-scale implementation work that spans multiple sessions or milestones and needs progress tracking with quality gates.
+
+## Routing
+
+- Primary coordinator: `@orchestrator`
+- Implementation agents: determined by task domain
+- Quality gate: `@validator`
+
+## Context notes
+
+- This workflow file, active platform rules, and selected agents or skills guide execution.
+- Attach the implementation plan, milestone definitions, and acceptance criteria per milestone.
+- Reuse `docs/specs/<spec-id>/` when present instead of maintaining a separate progress source of truth.
+- Read `ENGINEERING_RULES.md` first and `docs/foundation/TECH.md` next before starting milestone execution. Use `## Build And Validation` for the validated build sequence and `## Key Commands` for test/lint commands.
+
+## Skill Routing
+
+- Primary skills: `system-design`, `api-design`
+- Supporting skills (optional): `database-design`, `typescript-pro`, `javascript-pro`, `python-pro`, `golang-pro`, `react-expert`, `nextjs-developer`
+- Start with `system-design` for milestone planning. Load domain-specific skills per milestone based on implementation needs.
+
+## Workflow steps
+
+1. Review implementation plan and confirm milestone boundaries.
+2. Execute current milestone with focused implementation.
+3. Run quality gate validation at milestone completion.
+4. Update progress tracking and capture status.
+5. Adjust remaining plan, spec traceability, and doc refresh needs based on learnings.
+6. Proceed to next milestone or report completion.
+
+## Verification
+
+- Each milestone has clear acceptance criteria that are verified.
+- Quality gate passed before proceeding to next milestone.
+- Progress tracker updated with evidence of completion.
+- Remaining milestones adjusted for any scope changes.
+
+## Output Contract
+
+```yaml
+IMPLEMENT_TRACK_WORKFLOW_RESULT:
+  primary_agent: orchestrator
+  supporting_agents: [<milestone-agents>]
+  primary_skills: [system-design, api-design]
+  supporting_skills: [database-design?, typescript-pro?, javascript-pro?, python-pro?, golang-pro?, react-expert?, nextjs-developer?]
+  milestones:
+    - id: <milestone-id>
+      description: <string>
+      status: completed | in_progress | pending
+      acceptance_criteria_met: [<string>]
+      validation_evidence: <string>
+  overall_progress: <percentage>
+  scope_changes: [<string>] | []
+  spec_id: <string> | null
+  spec_root: docs/specs/<spec-id> | null
+  traceability_status: complete | partial | blocked
+  doc_impact: none | tech | rules | both
+  follow_up_items: [<string>] | []
+```
+
 If command arguments are provided, treat them as additional user context.
 '''

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

@@ -1,19 +1,85 @@
 description = "Plan and execute technology migrations, framework upgrades, and dependency updates with rollback safety, incremental verification, and zero-downtime transition."
 prompt = '''
-Follow the /migrate workflow from .gemini/workflows/migrate.md.
+Execute the native projection of the /migrate workflow.
+
+Plan and execute technology migrations, framework upgrades, and dependency updates with rollback safety, incremental verification, and zero-downtime transition.
 
 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: `system-design`, `code-review`, `unit-testing`, `typescript-best-practices`, `javascript-best-practices`, `python-best-practices`, `golang-best-practices`.
-- Local skill file hints if installed: `.gemini/skills/system-design/SKILL.md`, `.gemini/skills/code-review/SKILL.md`, `.gemini/skills/unit-testing/SKILL.md`, `.gemini/skills/typescript-best-practices/SKILL.md`, `.gemini/skills/javascript-best-practices/SKILL.md`, `.gemini/skills/python-best-practices/SKILL.md`, `.gemini/skills/golang-best-practices/SKILL.md`.
+- Local skill file hints if installed: `.agents/skills/system-design/SKILL.md`, `.agents/skills/code-review/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`.
 - 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.
+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 the researcher posture first.
+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:
+# Migrate Workflow
+
+## When to use
+
+Use this for technology migrations, framework upgrades, dependency updates, or major version transitions.
+
+## Routing
+
+- Primary specialist: `@code-archaeologist`
+- Implementation support: `@backend-specialist`, `@frontend-specialist`
+- Verification support: `@test-engineer`, `@validator`
+
+## Context notes
+
+- This workflow file, active platform rules, and selected agents or skills guide execution.
+- Attach the migration target, current versions, breaking change lists, and impact assessment.
+- Read `ENGINEERING_RULES.md` and `docs/foundation/TECH.md` first because migrations often change accepted patterns and current-state architecture at the same time. After migration, flag updates needed in `docs/foundation/ARCHITECTURE.md` for `## Risks And Tech Debt`.
+
+## Skill Routing
+
+- Primary skills: `legacy-modernizer`, `system-design`
+- Supporting skills (optional): `static-analysis`, `testing-patterns`, `typescript-pro`, `javascript-pro`, `python-pro`, `golang-pro`
+- Start with `legacy-modernizer` for migration methodology and `system-design` for system impact. Add `static-analysis` for automated codemod or compatibility analysis.
+
+## Workflow steps
+
+1. Assess current state and migration target.
+2. Map breaking changes and affected code paths.
+3. Plan incremental migration steps with rollback points.
+4. Execute migration one step at a time with verification.
+5. Update tests and documentation for new patterns.
+6. Set `doc_impact` when the migration changes architecture, deployment shape, boundaries, or design-system rules.
+7. Verify full system behavior after migration complete.
+
+## Verification
+
+- All breaking changes addressed.
+- Tests pass on migrated code.
+- Rollback tested at each migration step.
+- No degradation in performance or functionality.
+- Documentation updated for new patterns.
+
+## Output Contract
+
+```yaml
+MIGRATE_WORKFLOW_RESULT:
+  primary_agent: code-archaeologist
+  supporting_agents: [backend-specialist?, frontend-specialist?, test-engineer?, validator?]
+  primary_skills: [legacy-modernizer, system-design]
+  supporting_skills: [static-analysis?, testing-patterns?]
+  migration:
+    from: <string>
+    to: <string>
+    breaking_changes: [<string>]
+    steps_completed: [<string>]
+    rollback_points: [<string>]
+  verification:
+    tests_passed: true | false
+    performance_impact: <string>
+  doc_impact: none | tech | rules | both
+  follow_up_items: [<string>] | []
+```
+
 If command arguments are provided, treat them as additional user context.
 '''

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

@@ -1,19 +1,86 @@
 description = "Drive mobile implementation decisions for Flutter/cross-platform behavior and reliability."
 prompt = '''
-Follow the /mobile workflow from .gemini/workflows/mobile.md.
+Execute the native projection of the /mobile workflow.
+
+Drive mobile implementation decisions for Flutter/cross-platform behavior and reliability.
 
 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: `expo-app`, `react-native`, `stitch`, `frontend-design`, `swift-best-practices`, `kotlin-best-practices`.
-- Local skill file hints if installed: `.gemini/skills/expo-app/SKILL.md`, `.gemini/skills/react-native/SKILL.md`, `.gemini/skills/stitch/SKILL.md`, `.gemini/skills/frontend-design/SKILL.md`, `.gemini/skills/swift-best-practices/SKILL.md`, `.gemini/skills/kotlin-best-practices/SKILL.md`.
+- Local skill file hints if installed: `.agents/skills/expo-app/SKILL.md`, `.agents/skills/react-native/SKILL.md`, `.agents/skills/stitch/SKILL.md`, `.agents/skills/frontend-design/SKILL.md`, `.agents/skills/swift-best-practices/SKILL.md`, `.agents/skills/kotlin-best-practices/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.
+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 the researcher posture first.
+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:
+# Mobile Workflow
+
+## When to use
+
+Use this for mobile app development, Flutter architecture, Stitch-driven mobile screen handoff, native integrations, or platform-specific behavior.
+
+## Routing
+
+- Primary specialist: `@mobile-developer`
+- Design support: `@frontend-specialist`
+- Verification support: `@test-engineer`
+
+## Context notes
+
+- This workflow file, active platform rules, and selected agents or skills guide execution.
+- Attach platform targets (iOS, Android, both), Flutter version, and relevant screen/feature context.
+- Read `ENGINEERING_RULES.md` and `docs/foundation/TECH.md` before implementing non-trivial mobile work so screens and features follow the declared architecture and design-system rules. Check `docs/foundation/PRODUCT.md` for `## Domain Glossary` to use consistent terminology.
+
+## Skill Routing
+
+- Primary skills: `flutter-feature`, `mobile-design`
+- Supporting skills (optional): `stitch`, `i18n-localization`, `flutter-riverpod`, `flutter-go-router`, `flutter-design-system`, `flutter-testing`, `flutter-drift`, `flutter-offline-sync`, `flutter-state-machine`, `flutter-repository`, `dart-pro`, `swift-pro`, `kotlin-pro`
+- Start with `flutter-feature` for feature implementation and `mobile-design` for UX patterns. Add framework-specific Flutter skill when applicable. Add `i18n-localization` for multi-language support.
+- When the request starts from Stitch artifacts or a design sync, load `stitch` first and then pair it with `mobile-design` plus the narrowest mobile implementation skill for the target stack.
+
+## Workflow steps
+
+1. Clarify platform targets and feature requirements.
+2. Design architecture with platform-appropriate patterns.
+3. Implement with consideration for iOS/Android differences.
+4. Write widget and integration tests.
+5. Review for platform-specific edge cases and UX conventions.
+6. Set `doc_impact` if the feature changes navigation, shared UI rules, or mobile architecture conventions.
+
+## Verification
+
+- Runs correctly on both target platforms.
+- Platform-specific conventions respected (iOS/Android).
+- Touch targets and gesture feedback appropriate.
+- Widget tests cover core behavior.
+- Offline behavior tested if applicable.
+
+## Output Contract
+
+```yaml
+MOBILE_WORKFLOW_RESULT:
+  primary_agent: mobile-developer
+  supporting_agents: [frontend-specialist?, test-engineer?]
+  primary_skills: [flutter-feature, mobile-design]
+  supporting_skills: [stitch?, i18n-localization?, flutter-riverpod?, flutter-testing?, <flutter-specific>?]
+  implementation:
+    platforms: [ios, android]
+    architecture_decisions: [<string>]
+    changed_artifacts: [<path>]
+  testing:
+    widget_tests: [<path>]
+    integration_tests: [<path>] | []
+  platform_notes:
+    ios: [<string>] | []
+    android: [<string>] | []
+  doc_impact: none | tech | rules | both
+  follow_up_items: [<string>] | []
+```
+
 If command arguments are provided, treat them as additional user context.
 '''

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

@@ -1,19 +1,80 @@
 description = "Survey an unfamiliar codebase, map its architecture, identify patterns and conventions, and produce a structured orientation report for new contributors."
 prompt = '''
-Follow the /onboard workflow from .gemini/workflows/onboard.md.
+Execute the native projection of the /onboard workflow.
+
+Survey an unfamiliar codebase, map its architecture, identify patterns and conventions, and produce a structured orientation report for new contributors.
 
 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: `deep-research`, `system-design`, `database-design`, `typescript-best-practices`, `javascript-best-practices`, `python-best-practices`.
-- Local skill file hints if installed: `.gemini/skills/deep-research/SKILL.md`, `.gemini/skills/system-design/SKILL.md`, `.gemini/skills/database-design/SKILL.md`, `.gemini/skills/typescript-best-practices/SKILL.md`, `.gemini/skills/javascript-best-practices/SKILL.md`, `.gemini/skills/python-best-practices/SKILL.md`.
+- Local skill file hints if installed: `.agents/skills/deep-research/SKILL.md`, `.agents/skills/system-design/SKILL.md`, `.agents/skills/database-design/SKILL.md`, `.agents/skills/typescript-best-practices/SKILL.md`, `.agents/skills/javascript-best-practices/SKILL.md`, `.agents/skills/python-best-practices/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.
+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 the researcher posture first.
+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:
+# Onboard Workflow
+
+## When to use
+
+Use this when joining a new project, exploring an unfamiliar codebase, or preparing orientation material.
+
+## Routing
+
+- Primary specialist: `@researcher`
+- Architecture mapping: `@code-archaeologist`
+- Domain specialists as needed: `@backend-specialist`, `@frontend-specialist`
+
+## Context notes
+
+- This workflow file, active platform rules, and selected agents or skills guide execution.
+- Provide the repo URL, focus areas, and any specific questions to answer during onboarding.
+- Read `ENGINEERING_RULES.md` first, then `docs/foundation/TECH.md`, `docs/foundation/PRODUCT.md`, and `docs/foundation/ARCHITECTURE.md` when present so onboarding distinguishes the intended contract from current implementation reality. Use the `## Domain Glossary` in PRODUCT.md to learn project-specific terms, and `## Build And Validation` in TECH.md to set up the local environment.
+
+## Skill Routing
+
+- Primary skills: `deep-research`, `system-design`
+- Supporting skills (optional): `legacy-modernizer`, `database-design`, `typescript-pro`, `javascript-pro`, `python-pro`
+- Start with `deep-research` for systematic exploration and `system-design` for architecture mapping. Add `legacy-modernizer` for undocumented systems. Prefer repo evidence first; use external sources only when setup or dependency behavior cannot be confirmed locally.
+
+## Workflow steps
+
+1. Survey the project structure — directories, entry points, and configuration.
+2. Map the architecture — components, data flow, and integration points.
+3. Identify patterns — naming conventions, design patterns, and coding standards.
+4. Document dependencies — external services, databases, and APIs.
+5. Produce orientation report with development setup instructions.
+
+## Verification
+
+- All major components identified and documented.
+- Development setup instructions verified (can be followed by a newcomer).
+- Architecture diagram or description covers main data flows.
+- Key patterns and conventions explicitly documented.
+
+## Output Contract
+
+```yaml
+ONBOARD_WORKFLOW_RESULT:
+  primary_agent: researcher
+  supporting_agents: [code-archaeologist?, backend-specialist?, frontend-specialist?]
+  primary_skills: [deep-research, system-design]
+  supporting_skills: [legacy-modernizer?, database-design?]
+  project_overview:
+    purpose: <string>
+    tech_stack: [<string>]
+    architecture: <string>
+  key_components: [<string>]
+  patterns_and_conventions: [<string>]
+  development_setup: [<step>]
+  dependencies: [<string>]
+  knowledge_gaps: [<string>] | []
+```
+
 If command arguments are provided, treat them as additional user context.
 '''

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

@@ -1,19 +1,88 @@
 description = "Coordinate multiple specialists to solve cross-cutting tasks with explicit ownership, validation gates, and repeat-until-good iteration."
 prompt = '''
-Follow the /orchestrate workflow from .gemini/workflows/orchestrate.md.
+Execute the native projection of the /orchestrate workflow.
+
+Coordinate multiple specialists to solve cross-cutting tasks with explicit ownership, validation gates, and repeat-until-good iteration.
 
 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: `system-design`, `api-design`, `database-design`, `deep-research`, `mcp-server-builder`, `tech-doc`, `prompt-engineering`, `skill-creator`.
-- Local skill file hints if installed: `.gemini/skills/system-design/SKILL.md`, `.gemini/skills/api-design/SKILL.md`, `.gemini/skills/database-design/SKILL.md`, `.gemini/skills/deep-research/SKILL.md`, `.gemini/skills/mcp-server-builder/SKILL.md`, `.gemini/skills/tech-doc/SKILL.md`, `.gemini/skills/prompt-engineering/SKILL.md`, `.gemini/skills/skill-creator/SKILL.md`.
+- Local skill file hints if installed: `.agents/skills/system-design/SKILL.md`, `.agents/skills/api-design/SKILL.md`, `.agents/skills/database-design/SKILL.md`, `.agents/skills/deep-research/SKILL.md`, `.agents/skills/mcp-server-builder/SKILL.md`, `.agents/skills/tech-doc/SKILL.md`, `.agents/skills/prompt-engineering/SKILL.md`, `.agents/skills/skill-creator/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.
+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 the researcher posture first.
+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:
+# Orchestrate Workflow
+
+## When to use
+
+Use this when a task spans multiple domains (backend + frontend, security + infrastructure, etc.) and requires coordinated specialist work with validation between steps.
+
+## Routing
+
+- Primary coordinator: `@orchestrator`
+- Specialist routing determined by task decomposition — delegates to `@backend-specialist`, `@frontend-specialist`, `@database-architect`, `@security-auditor`, `@devops-engineer`, `@test-engineer`, `@mobile-developer`, or other specialist agents as needed.
+- Validation support: `@validator`
+
+## Context notes
+
+- This workflow file, active platform rules, and selected agents or skills guide execution.
+- Attach the full task description, constraints, acceptance criteria, and relevant context when starting.
+- Read `ENGINEERING_RULES.md` and `docs/foundation/TECH.md` before decomposing non-trivial work. Check `docs/foundation/TECH.md` for build/validation commands and `docs/foundation/PRODUCT.md` for domain glossary. Then reuse any existing `docs/specs/<spec-id>/` pack as the handoff source of truth.
+
+## Skill Routing
+
+- Primary skills: `system-design`, `api-design`
+- Supporting skills (optional): `database-design`, `deep-research`, `mcp-server-builder`, `openai-docs`, `prompt-engineering`, `skill-creator`
+- Start with `system-design` for system design coordination and `api-design` for integration contracts. Add `deep-research` before implementation when the coordination challenge depends on fresh external facts or public comparison.
+
+## Workflow steps
+
+1. Decompose the task into discrete work items with acceptance criteria.
+2. Identify dependencies and determine execution order (DAG).
+3. Delegate each task to the best specialist agent with full context.
+4. Validate each deliverable against acceptance criteria via independent validation.
+5. Iterate on failed validations with specific feedback (max 3 iterations).
+6. Surface `doc_impact` when the coordinated work changes architecture, boundaries, scale, or the design system.
+7. Integrate outputs, verify cross-task consistency, and report results.
+
+## Verification
+
+- Each task validated independently against its acceptance criteria.
+- Cross-task consistency check after integration.
+- Run any applicable automated tests or checks.
+- Final validation pass on combined result.
+
+## Output Contract
+
+```yaml
+ORCHESTRATE_WORKFLOW_RESULT:
+  primary_agent: orchestrator
+  supporting_agents: [<specialist-agents-used>]
+  primary_skills: [system-design, api-design]
+  supporting_skills: [<supporting-skills-used>]
+  spec_id: <string> | null
+  spec_root: docs/specs/<spec-id> | null
+  task_count: <number>
+  completed: <number>
+  failed: <number>
+  tasks:
+    - id: <task-id>
+      agent: <agent-name>
+      status: completed | failed | skipped
+      iterations: <number>
+      validation_evidence: <string>
+  integration_status: clean | conflicts_resolved | issues_remaining
+  doc_impact: none | tech | rules | both
+  remaining_risks: [<string>] | []
+  follow_up_actions: [<string>] | []
+```
+
 If command arguments are provided, treat them as additional user context.
 '''

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

@@ -1,19 +1,94 @@
 description = "Build a decision-complete implementation plan with interfaces, failure modes, and acceptance criteria."
 prompt = '''
-Follow the /plan workflow from .gemini/workflows/plan.md.
+Execute the native projection of the /plan workflow.
+
+Build a decision-complete implementation plan with interfaces, failure modes, and acceptance criteria.
 
 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: `system-design`, `api-design`, `database-design`, `deep-research`, `mcp-server-builder`, `tech-doc`, `prompt-engineering`, `skill-creator`.
-- Local skill file hints if installed: `.gemini/skills/system-design/SKILL.md`, `.gemini/skills/api-design/SKILL.md`, `.gemini/skills/database-design/SKILL.md`, `.gemini/skills/deep-research/SKILL.md`, `.gemini/skills/mcp-server-builder/SKILL.md`, `.gemini/skills/tech-doc/SKILL.md`, `.gemini/skills/prompt-engineering/SKILL.md`, `.gemini/skills/skill-creator/SKILL.md`.
+- Local skill file hints if installed: `.agents/skills/system-design/SKILL.md`, `.agents/skills/api-design/SKILL.md`, `.agents/skills/database-design/SKILL.md`, `.agents/skills/deep-research/SKILL.md`, `.agents/skills/mcp-server-builder/SKILL.md`, `.agents/skills/tech-doc/SKILL.md`, `.agents/skills/prompt-engineering/SKILL.md`, `.agents/skills/skill-creator/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.
+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 the researcher posture first.
+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:
+# Plan Workflow
+
+## When to use
+
+Use this when starting a new feature, project, or significant change that needs a structured implementation plan before coding begins.
+
+## Routing
+
+- Primary coordinator: `@project-planner`
+- Architecture support: `@orchestrator`
+- Domain validation: `@backend-specialist`, `@frontend-specialist`, `@database-architect`
+
+## Context notes
+
+- This workflow file, active platform rules, and selected agents or skills guide execution.
+- Attach the feature request, problem statement, constraints, and any existing design documents.
+- Read `ENGINEERING_RULES.md` first and `docs/foundation/TECH.md` next when they exist before finalizing a non-trivial plan. Also check `docs/foundation/PRODUCT.md` for domain glossary and `docs/foundation/ARCHITECTURE.md` for crosscutting concerns and dependency rules.
+- Reuse an existing `docs/specs/<spec-id>/` pack when the change already has one instead of creating a parallel planning track.
+
+## Skill Routing
+
+- Primary skills: `system-design`, `api-design`
+- Supporting skills (optional): `database-design`, `deep-research`, `mcp-server-builder`, `openai-docs`, `prompt-engineering`, `skill-creator`
+- Start with `system-design` for system design and `api-design` for API contracts. Add `database-design` when data modeling is central, `deep-research` when fresh external knowledge or public comparison is needed.
+
+## Workflow steps
+
+1. Clarify scope, success criteria, and constraints.
+2. Research existing patterns and dependencies, starting in-repo and escalating to `deep-research` only when outside evidence is required.
+3. Decompose into tasks with ownership and dependencies.
+4. Define interfaces, contracts, and failure modes.
+5. Produce acceptance criteria for each milestone.
+6. Record `architecture_impact`, `doc_impact`, and `traceability_status` when the work is non-trivial.
+7. Identify risks, unknowns, and mitigation strategies.
+
+## Verification
+
+- Every task has an owner, acceptance criteria, and verification approach.
+- Dependencies form a valid DAG with no cycles.
+- Risk assessment covers top 3 failure scenarios.
+- Plan reviewed against existing codebase conventions.
+
+## Output Contract
+
+```yaml
+PLAN_WORKFLOW_RESULT:
+  primary_agent: project-planner
+  supporting_agents: [orchestrator?, backend-specialist?, frontend-specialist?, database-architect?]
+  primary_skills: [system-design, api-design]
+  supporting_skills: [database-design?, deep-research?, mcp-server-builder?]
+  spec_id: <string> | null
+  spec_root: docs/specs/<spec-id> | null
+  plan:
+    scope_summary: <string>
+    tasks:
+      - id: <task-id>
+        description: <string>
+        owner: <agent-name>
+        dependencies: [<task-id>]
+        acceptance_criteria: [<string>]
+    interfaces: [<string>]
+    risks: [<string>]
+    milestones: [<string>]
+  architecture_impact:
+    summary: <string>
+    affects_structure: true | false
+    affects_design_system: true | false
+  doc_impact: none | tech | rules | both
+  traceability_status: complete | partial | blocked
+  follow_up_items: [<string>] | []
+```
+
 If command arguments are provided, treat them as additional user context.
 '''

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

@@ -1,19 +1,82 @@
 description = "Improve maintainability while preserving behavior through incremental safe refactoring."
 prompt = '''
-Follow the /refactor workflow from .gemini/workflows/refactor.md.
+Execute the native projection of the /refactor workflow.
+
+Improve maintainability while preserving behavior through incremental safe refactoring.
 
 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: `code-review`, `system-design`, `unit-testing`, `typescript-best-practices`, `javascript-best-practices`, `python-best-practices`, `golang-best-practices`.
-- Local skill file hints if installed: `.gemini/skills/code-review/SKILL.md`, `.gemini/skills/system-design/SKILL.md`, `.gemini/skills/unit-testing/SKILL.md`, `.gemini/skills/typescript-best-practices/SKILL.md`, `.gemini/skills/javascript-best-practices/SKILL.md`, `.gemini/skills/python-best-practices/SKILL.md`, `.gemini/skills/golang-best-practices/SKILL.md`.
+- Local skill file hints if installed: `.agents/skills/code-review/SKILL.md`, `.agents/skills/system-design/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`.
 - 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.
+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 the researcher posture first.
+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:
+# Refactor Workflow
+
+## When to use
+
+Use this when improving code structure, reducing tech debt, or modularizing without changing behavior.
+
+## Routing
+
+- Primary specialist: `@code-archaeologist`
+- Domain support: `@backend-specialist`, `@frontend-specialist`
+- Verification support: `@test-engineer`, `@validator`
+
+## Context notes
+
+- This workflow file, active platform rules, and selected agents or skills guide execution.
+- Attach the target code, pain points, and any constraints on what can change.
+- Read `ENGINEERING_RULES.md` and `docs/foundation/TECH.md` first so behavior-preserving structure changes do not drift from the accepted architecture contract. Check `docs/foundation/ARCHITECTURE.md` for `## Dependency Rules` and `## Crosscutting Concerns` before restructuring.
+
+## Skill Routing
+
+- Primary skills: `static-analysis`, `legacy-modernizer`
+- Supporting skills (optional): `testing-patterns`, `system-design`, `typescript-pro`, `javascript-pro`, `python-pro`, `golang-pro`
+- Start with `static-analysis` for automated code quality assessment. Add `legacy-modernizer` for modernization patterns. Add `testing-patterns` when refactoring needs test coverage to proceed safely.
+
+## Workflow steps
+
+1. Map the current structure and identify refactoring targets.
+2. Ensure adequate test coverage before modifying (add tests if needed).
+3. Apply one refactoring at a time with behavior preservation.
+4. Verify behavior unchanged after each step.
+5. Document the improved structure and any conventions established.
+6. Set `doc_impact` when the refactor changes project structure, module boundaries, or design-system conventions.
+
+## Verification
+
+- All existing tests pass after each refactoring step.
+- No behavioral changes introduced (unless explicitly intended).
+- Code quality metrics improved (complexity, coupling, cohesion).
+- New tests added for any gaps discovered during refactoring.
+
+## Output Contract
+
+```yaml
+REFACTOR_WORKFLOW_RESULT:
+  primary_agent: code-archaeologist
+  supporting_agents: [backend-specialist?, frontend-specialist?, test-engineer?, validator?]
+  primary_skills: [static-analysis, legacy-modernizer]
+  supporting_skills: [testing-patterns?, system-design?]
+  refactoring_summary:
+    targets: [<string>]
+    changes_applied: [<string>]
+    behavior_preserved: true | false
+  quality_improvement:
+    complexity_before: <string>
+    complexity_after: <string>
+  doc_impact: none | tech | rules | both
+  tests_added: [<test-file-path>] | []
+  follow_up_items: [<string>] | []
+```
+
 If command arguments are provided, treat them as additional user context.
 '''