oh-my-agent-commandcode 0.0.0-stage → 20.38.4

package/skills/oma-dev-workflow/SKILL.md

@@ -0,0 +1,375 @@
+---
+name: oma-dev-workflow
+description: Configure development tasks, git hooks, CI/CD, or release
+  automation. Use when creating or fixing a repository development workflow.
+---
+
+# Dev Workflow - Monorepo Task Automation Specialist
+
+## Scheduling
+
+### Goal
+Set up, run, optimize, and troubleshoot reproducible development workflows using `mise`, language-specific checks, commitlint, validation pipelines, CI/CD, migrations, i18n builds, and release coordination.
+
+### Intent signature
+- User asks about dev servers, mise tasks, lint/format/typecheck/test/build, git hooks, CI/CD, migrations, generated clients, i18n builds, or release automation.
+- User needs workflow execution or developer environment setup rather than product feature implementation.
+- User asks to configure Ruff/pyrefly, Biome/TypeScript 7, Dart/Flutter checks, Hadolint, or commitlint.
+
+### When to use
+
+- Running development servers for monorepo with multiple applications
+- Executing lint, format, typecheck across multiple apps in parallel
+- Managing database migrations and schema changes
+- Generating API clients or code from schemas
+- Building internationalization (i18n) files
+- Executing production builds and deployment preparation
+- Running parallel tasks in monorepo context
+- Setting up pre-commit validation workflows
+- Configuring language-specific lint, format, and typecheck tools, Dockerfile linting, and commit-message validation
+- Troubleshooting mise task failures or configuration issues
+- Optimizing CI/CD pipelines with mise
+
+### When NOT to use
+
+- Database schema design or query tuning -> use DB Agent
+- Backend API implementation -> use Backend Agent
+- Frontend UI implementation -> use Frontend Agent
+- Mobile development -> use Mobile Agent
+
+### Expected inputs
+- Requested workflow operation, affected apps/packages, and current monorepo structure
+- Project manifests, lockfiles, tool configs, `mise.toml`, task definitions, CI files, hook manager, and failure logs when relevant
+- Desired validation, setup, or release outcome
+
+### Expected outputs
+- Executed or documented mise task workflow
+- Updated workflow config, CI/CD pipeline, hooks, env template, or release guidance when requested
+- Project-local tool dependencies/configs and runnable `lint`, `format`, `format:check`, `typecheck`, and commitlint tasks for the selected profiles
+- Status report with commands, outputs, failures, and next actions
+
+### Dependencies
+- `mise`, project task definitions, runtime versions, package managers behind mise tasks
+- Resource guides for validation, database patterns, API workflows, i18n, release coordination, and troubleshooting
+- Selected language toolchains and locally provisioned commitlint; no package downloads from Git hooks
+
+### Control-flow features
+- Branches by affected apps, task dependency graph, port availability, task failure, and CI/release context
+- Calls local process commands; may write workflow/config files
+- Must avoid destructive tasks and secrets in workflow configs
+
+## Structural Flow
+
+### Entry
+1. Identify affected apps/packages and requested workflow outcome.
+2. Read `mise.toml` files and available tasks.
+3. Determine whether tasks can run in parallel or must be sequential.
+
+### Scenes
+1. **PREPARE**: Analyze requirements, task graph, runtime prerequisites, and ports.
+2. **ACQUIRE**: Inspect mise config, task definitions, CI hooks, env patterns, and logs.
+3. **ACT**: Run or modify mise tasks, workflow configs, or validation pipelines.
+4. **VERIFY**: Check exit codes, generated artifacts, logs, and CI compatibility.
+5. **FINALIZE**: Report command status, duration, failures, and next steps.
+
+### Transitions
+- If runtime versions changed, run `mise install`.
+- If changed-file tasks exist, prefer changed-scope validation.
+- If port is occupied, resolve or select another port before starting dev server.
+- If a task is unfamiliar, read its definition before running.
+- For setup, preserve existing tools and commands; apply language defaults only where configuration is missing. For execution-only requests, use existing checks without installing or replacing tools.
+- `/stack-set` detects and records the stack. This skill owns tool setup and task/CI wiring; domain skills consume the resulting verification commands.
+
+### Failure and recovery
+- If task is missing, run `mise tasks --all`.
+- If runtime is missing, run or recommend `mise install`.
+- If task hangs, check for prompts or long-running dev-server behavior.
+- If destructive task is requested, require confirmation.
+- If a selected checker cannot run, report that check as incomplete and fix its setup within scope; do not replace it with a passing placeholder or a build.
+- If a hook skips because another check is still running and exits 0, that push was not validated. Stop the owned previous run, or exit nonzero. Do not hide a gate failure with `|| true`.
+
+### Exit
+- Success: workflow runs or config changes are verified.
+- Partial success: task failures, missing runtime, or CI/environment blockers are explicit.
+
+## Logical Operations
+
+### Actions
+| Action | SSL primitive | Evidence |
+|--------|---------------|----------|
+| Read task definitions | `READ` | `mise.toml`, CI config |
+| Select task strategy | `SELECT` | Parallel/sequential/changed-scope |
+| Run workflow commands | `CALL_TOOL` | `mise run`, `mise install`, `mise tasks` |
+| Write workflow config | `WRITE` | Hooks, CI, env templates |
+| Validate outputs | `VALIDATE` | Exit codes, logs, artifacts |
+| Report status | `NOTIFY` | Final workflow summary |
+
+### Tools and instruments
+- `mise`, shell, CI/CD tooling, project package manager tasks behind mise
+- Resource guides for validation, database, API, i18n, release, and troubleshooting
+
+### Canonical command path
+1. Inspect affected app manifests, lockfiles, tool configs, `mise.toml`, CI, hooks, and any `stack/stack.yaml`. Read task definitions and use `mise tasks --all` to discover existing commands.
+2. For setup or tool changes, load the selected tooling profiles from References. Configure missing dependencies, settings, and tasks with the detected package manager; preserve existing tool choices. For checks alone, skip setup.
+3. Expose applicable checks as `lint`, `format:check`, and `typecheck`; keep mutating `format` separate. A `check` task can aggregate non-emitting checks. Connect existing stack `verify.syntax.cmd` to that task without adding unsupported schema keys; preserve `verify.tests` and domain-specific scans.
+4. For hook/CI setup, load the validation pipeline. Provision locked local tools first, preserve the existing hook manager, and connect commitlint to the local `commit-msg` hook. Staged lint stays on pre-commit. Typecheck the whole affected app on the push gate when commit time is the constraint. Configure CI for app checks and tests. Default hooks and required CI run hermetic checks and unit tests only; integration tests get a separate opt-in task.
+5. Before relaunching local validation, follow the validation pipeline's repeated-run guidance. A skipped run is not a pass. Run the configured `mise run check` aggregate, or the applicable individual `lint`, `format:check`, and `typecheck` tasks, plus the relevant hermetic tests. Do not start Docker or external services for validation. Run each underlying checker once. Use `mise run //{path}:{task}` for configured monorepos; typecheck the complete affected app rather than individual changed files.
+6. Report the selected tools, commands, checks passed, and any unavailable or inapplicable checks. Builds remain subject to the execution policy.
+
+### Resource scope
+| Scope | Resource target |
+|-------|-----------------|
+| `CODEBASE` | `mise.toml`, CI configs, scripts, generated clients |
+| `LOCAL_FS` | Env templates, build outputs, logs |
+| `PROCESS` | mise, build, test, lint, dev-server commands |
+| `CREDENTIALS` | Secrets must not be hardcoded in workflow configs |
+
+### Preconditions
+- Target workflow and affected project area are identifiable.
+- Task definitions can be discovered or missing-task state is reported.
+
+### Effects and side effects
+- May start dev servers, run tests/builds, generate clients, run migrations, or edit workflow configs.
+- May consume CPU/time or occupy ports.
+
+### Guardrails
+
+1. Always use `mise run` tasks instead of direct package manager commands
+2. Run `mise install` after pulling changes that might update runtime versions
+3. Use parallel tasks (`mise run lint`, `mise run test`) for independent operations. Cap concurrency when a measurement shows more workers slow the same suite
+4. Run lint and test on changed scope. Keep a repository selector that already fails closed on shared or unknown paths; do not replace it with the generic affected-checks helper
+5. Validate commit messages with commitlint before committing
+6. Run pre-commit validation pipeline for staged files only
+7. Configure CI to skip unchanged apps for faster builds
+8. Check `mise tasks --all` to discover available tasks before running
+9. Verify task output and exit codes for CI/CD integration
+10. Document task dependencies in mise.toml comments
+11. Use consistent task naming conventions across apps
+12. Enable mise in CI/CD pipelines for reproducible builds
+13. Pin runtime versions in mise.toml for consistency
+14. Test tasks locally before committing CI/CD changes
+15. Never fetch packages from a Git hook. When a mise task already runs a checker, call that task. A hook running under `mise exec` may call the pinned local binary directly
+16. Never modify mise.toml without understanding task dependencies
+17. Never skip `mise install` after toolchain version updates
+18. Never run dev servers without checking port availability first
+19. Never commit past a failing staged lint. Typecheck the whole affected app on the push gate when doing it on every commit would dominate commit time
+20. Never ignore task failures - always investigate root cause
+21. Never hardcode secrets in mise.toml files
+22. Never assume task availability - always verify with `mise tasks`
+23. Never run destructive tasks (clean, reset) without confirmation
+24. Never skip reading task definitions before running unfamiliar tasks
+25. Always quote task names containing `:` in mise.toml (`[tasks."lint:changed"]`) — unquoted colons fail TOML parsing
+26. Always set `monorepo_root = true` (plus `[monorepo].config_roots`) in the root mise.toml before using `//path:task` syntax
+27. Keep check tasks non-mutating; run format/fix tasks only within the requested edit scope, and never rewrite unstaged changes from a Git hook
+28. Keep integration tests in a separate opt-in task and out of `git:pre-commit`, `git:pre-push`, `validate:changed`, and required CI gates
+29. Prefer hermetic tests: do not introduce tests that need Docker, containers (including testcontainers), or external services. If unavoidable, isolate them in the integration task and document the dependency
+
+### Technical Guidelines
+
+### Prerequisites
+
+Reuse an existing `mise` installation. If it is missing, install it with a package manager supported by your platform. For example, with Homebrew already installed:
+
+```bash
+brew install mise
+```
+
+For other platforms, use a package-manager method from the [official installation guide](https://mise.jdx.dev/installing-mise.html). Do not pipe a remote installation script directly into a shell.
+
+Follow the [shell setup guide](https://mise.jdx.dev/shell-setup.html) for your current shell when activation is needed. Check for existing activation before editing shell configuration, and use `mise` from `PATH` rather than assuming `~/.local/bin/mise`.
+
+```bash
+# Verify mise is available
+mise --version
+
+# Install all runtimes defined in mise.toml
+mise install
+
+# Verify installation
+mise list
+```
+
+### Project Structure (Monorepo)
+
+```
+project-root/
+├── mise.toml            # Root task definitions
+├── apps/
+│   ├── api/            # Backend application
+│   │   └── mise.toml   # App-specific tasks
+│   ├── web/            # Frontend application
+│   │   └── mise.toml
+│   └── mobile/         # Mobile application
+│       └── mise.toml
+├── packages/
+│   ├── shared/         # Shared libraries
+│   └── config/         # Shared configuration
+└── scripts/            # Utility scripts
+```
+
+The root `mise.toml` must enable monorepo task paths, or every `//path:task` invocation fails with "require a monorepo root configuration":
+
+```toml
+# Root mise.toml — monorepo_root is a top-level key (before any [table])
+monorepo_root = true
+
+[monorepo]
+config_roots = ["apps/*", "packages/*"]
+```
+
+### Task Syntax
+
+**Root-level tasks:**
+```bash
+mise run lint        # Lint all apps (parallel)
+mise run test        # Test all apps (parallel)
+mise run dev         # Start all dev servers
+mise run build       # Production builds
+```
+
+**App-specific tasks:**
+```bash
+# Syntax: mise run //{path}:{task}
+# Requires monorepo_root = true in root mise.toml (see Project Structure)
+mise run //apps/api:dev
+mise run //apps/api:test
+mise run //apps/web:build
+```
+
+**TOML quoting rule:** task names containing `:` must be quoted — `[tasks."gen:api"]`, never `[tasks.gen:api]` (unquoted colons are a TOML parse error).
+
+### Common Task Patterns
+
+| Task Type | Purpose | Example |
+|-----------|---------|---------|
+| `dev` | Start development server | `mise run //apps/api:dev` |
+| `build` | Production build | `mise run //apps/web:build` |
+| `test` | Run test suite | `mise run //apps/api:test` |
+| `lint` | Run linter | `mise run lint` |
+| `format` | Format code | `mise run format` |
+| `format:check` | Check formatting without writes | `mise run format:check` |
+| `typecheck` | Type checking | `mise run typecheck` |
+| `check` | Aggregate applicable non-emitting checks | `mise run check` |
+| `migrate` | Database migrations | `mise run //apps/api:migrate` |
+
+### Reference Guide
+
+| Topic | Resource File | When to Load |
+|-------|---------------|--------------|
+| Validation Pipeline | `resources/validation-pipeline.md` | Git hooks, CI/CD, change-based testing, repeated local validation |
+| Database & Infrastructure | `resources/database-patterns.md` | Migrations, optional local Docker infra (not a test dependency) |
+| API Generation | `resources/api-workflows.md` | Generating API clients |
+| i18n Patterns | `resources/i18n-patterns.md` | Internationalization |
+| Release Coordination | `resources/release-coordination.md` | Versioning, changelog, releases |
+| Troubleshooting | `resources/troubleshooting.md` | Debugging issues |
+
+### Task Dependencies
+
+Define dependencies in `mise.toml`:
+
+```toml
+[tasks.build]
+depends = ["lint", "test"]
+run = "echo 'Building after lint and test pass'"
+
+[tasks.dev]
+depends = ["//apps/api:dev", "//apps/web:dev"]
+```
+
+### Parallel vs Sequential Execution
+
+**Parallel (independent tasks):**
+```bash
+# Runs all lint tasks simultaneously (via depends)
+mise run lint
+
+# mise-native parallel execution of multiple tasks
+mise run lint ::: test
+```
+
+**Sequential (dependent tasks):**
+```bash
+# Runs in order: lint → test → build
+mise run lint && mise run test && mise run build
+```
+
+**Mixed approach:**
+```bash
+# Start dev servers in background
+mise run //apps/api:dev &
+mise run //apps/web:dev &
+wait
+```
+
+### Environment Variables
+
+Common patterns for monorepo env vars:
+
+```bash
+# Database
+DATABASE_URL=postgresql://user:pass@localhost:5432/db
+
+# Cache
+REDIS_URL=redis://localhost:6379/0
+
+# API
+API_URL=http://localhost:8000
+
+# Frontend
+PUBLIC_API_URL=http://localhost:8000
+```
+
+### Output Templates
+
+When setting up development environment:
+1. Runtime installation verification (`mise list`)
+2. Dependency installation commands per app
+3. Environment variable template (.env.example)
+4. Development server startup commands
+5. Common task quick reference
+
+When running tasks:
+1. Command executed with full path
+2. Expected output summary
+3. Duration and success/failure status
+4. Next recommended actions
+
+When troubleshooting:
+1. Diagnostic commands (`mise config`, `mise doctor`)
+2. Common issue solutions
+3. Port/process conflict resolution
+4. Cleanup commands if needed
+
+### Troubleshooting Guide
+
+| Issue | Solution |
+|-------|----------|
+| Task not found | Run `mise tasks --all` to list available tasks |
+| Runtime not found | Run `mise install` to install missing runtime |
+| Task hangs | Check for interactive prompts, use `--yes` if available |
+| Port already in use | Find process: `lsof -ti:PORT` then kill |
+| Permission denied | Check file permissions, try with proper user |
+| Missing dependencies | Run `mise run install` or app-specific install |
+
+### How to Execute
+
+Follow the core workflow step by step:
+1. **Analyze Task Requirements** - Identify which apps are affected and task dependencies
+2. **Check mise Configuration** - Verify mise.toml structure and available tasks
+3. **Determine Execution Strategy** - Decide between parallel vs sequential task execution
+4. **Run Prerequisites** - Install runtimes, dependencies if needed
+5. **Execute Tasks** - Run mise tasks with proper error handling
+6. **Verify Results** - Check output, logs, and generated artifacts
+7. **Report Status** - Summarize success/failure with actionable next steps
+
+### Execution Protocol (CLI Mode)
+
+## References
+
+- Tooling profiles: [resources/tooling-profiles.md](resources/tooling-profiles.md) (configure or change Python, JS/TS, Dart/Flutter, Dockerfile, or commitlint tooling)
+- Clarification: `../_shared/core/clarification-protocol.md`
+- Task decomposition: `../_shared/core/difficulty-guide.md` (unresolved scope or dependencies)
+
+### Knowledge Reference
+
+mise, task runner, monorepo, dev server, lint, format, test, typecheck, build, deployment, ci/cd, parallel execution, workflow, automation, tooling

package/skills/oma-dev-workflow/resources/affected-checks.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Run existing app checks for staged changes or a complete branch diff."""
+import argparse
+from pathlib import Path
+import subprocess
+
+APPS = ("web", "api", "mobile")
+# Adapt each entry to applicable apps; absent required tasks must fail.
+CHECK_APPS = {kind: APPS for kind in ("check", "lint", "typecheck", "test")}
+
+def affected_apps(paths):
+    """Unknown/shared/root paths conservatively affect every example app."""
+    affected = set()
+    for path in paths:
+        parts = path.split("/")
+        if len(parts) >= 3 and parts[0] == "apps" and parts[1] in APPS:
+            affected.add(parts[1])
+        else:
+            return list(APPS)
+    return [app for app in APPS if app in affected]
+
+def changed_paths(repo, *, staged=False, base=None):
+    prefix = ["git", "-C", str(repo)]
+    if staged:
+        args = ["diff", "--cached", "--name-only", "-z"]
+        result = subprocess.run(prefix + args, check=True, capture_output=True)
+        return [p.decode("utf-8", "surrogateescape") for p in result.stdout.split(b"\0") if p]
+    if not base:
+        return None # unknown base: run every app instead of silently skipping
+    result = subprocess.run(prefix + ["diff", "--name-only", "-z", f"{base}...HEAD"],
+                            capture_output=True)
+    if result.returncode:
+        return None
+    working = subprocess.run(prefix + ["diff", "--name-only", "-z", "HEAD"],
+                             check=True, capture_output=True)
+    return [p.decode("utf-8", "surrogateescape")
+            for p in (result.stdout + working.stdout).split(b"\0") if p]
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--kind", choices=tuple(CHECK_APPS), required=True)
+    parser.add_argument("--staged", action="store_true")
+    parser.add_argument("--base", help="PR target revision or configured target branch")
+    parser.add_argument("--repo", type=Path, default=Path.cwd())
+    parser.add_argument("--list", action="store_true", help="Print app names without running checks")
+    args = parser.parse_args()
+    paths = changed_paths(args.repo, staged=args.staged, base=args.base)
+    apps = list(APPS) if paths is None else affected_apps(paths)
+    apps = [app for app in apps if app in CHECK_APPS[args.kind]]
+    for app in apps:
+        if args.list:
+            print(app)
+        else:
+            subprocess.run(["mise", "run", f"//apps/{app}:{args.kind}"],
+                           cwd=args.repo, check=True)
+
+if __name__ == "__main__":
+    main()

package/skills/oma-dev-workflow/resources/api-workflows.md

@@ -0,0 +1,58 @@
+# API Generation Workflows
+
+Generate API clients from OpenAPI schemas.
+
+## OpenAPI to Client Pipeline
+
+```bash
+# 1. Generate OpenAPI schema from backend
+mise run //apps/api:gen:openapi
+
+# 2. Generate TypeScript client for web
+mise run //apps/web:gen:api
+
+# 3. Generate Dart client for mobile
+mise run //apps/mobile:gen:api
+```
+
+## Backend Tasks
+
+```toml
+# apps/api/mise.toml
+[tasks."gen:openapi"]
+description = "Generate OpenAPI schema"
+run = "uv run python -c 'from src.main import app; import json; print(json.dumps(app.openapi()))' > openapi.json"
+```
+
+## Web Tasks
+
+```toml
+# apps/web/mise.toml
+[tasks."gen:api"]
+description = "Generate API client from OpenAPI"
+depends = ["//apps/api:gen:openapi"]
+run = "bunx orval"
+```
+
+## Mobile Tasks
+
+```toml
+# apps/mobile/mise.toml
+[tasks."gen:api"]
+description = "Generate API client from OpenAPI"
+depends = ["//apps/api:gen:openapi"]
+run = "flutter pub run swagger_parser"
+```
+
+## Root-Level API Generation
+
+```toml
+# Root mise.toml
+[tasks."gen:api"]
+description = "Generate API clients for all apps"
+depends = [
+  "//apps/api:gen:openapi",
+  "//apps/web:gen:api",
+  "//apps/mobile:gen:api"
+]
+```

package/skills/oma-dev-workflow/resources/database-patterns.md

@@ -0,0 +1,107 @@
+# Database & Local Infrastructure
+
+Database migration workflows and local development infrastructure.
+
+## Migration Tasks
+
+```toml
+# apps/api/mise.toml
+[tasks.migrate]
+description = "Run Alembic migrations"
+run = "uv run alembic upgrade head"
+
+[tasks."migrate:create"]
+description = "Create new migration"
+usage = 'arg "<name>"'
+run = 'uv run alembic revision --autogenerate -m "$usage_name"'
+
+[tasks."migrate:check"]
+description = "Check migration status"
+run = "uv run alembic current"
+
+[tasks."migrate:history"]
+description = "Show migration history"
+run = "uv run alembic history --verbose"
+
+[tasks."migrate:rollback"]
+description = "Rollback one migration"
+run = "uv run alembic downgrade -1"
+
+[tasks."migrate:reset"]
+description = "Reset database (all down then up)"
+run = "uv run alembic downgrade base && uv run alembic upgrade head"
+```
+
+## Creating Migrations
+
+```bash
+# Create new migration
+mise run //apps/api:migrate:create "add users table"
+
+# Review generated migration
+# Edit: apps/api/alembic/versions/xxx_add_users_table.py
+
+# Apply migration
+mise run //apps/api:migrate
+
+# Check current version
+mise run //apps/api:migrate:check
+
+# View history
+mise run //apps/api:migrate:history
+
+# Rollback (if needed)
+mise run //apps/api:migrate:rollback
+```
+
+## Root-Level Database Tasks
+
+```toml
+# Root mise.toml
+[tasks."db:migrate"]
+description = "Run all database migrations"
+depends = ["//apps/api:migrate"]
+
+[tasks."db:reset"]
+description = "Reset all databases"
+depends = ["//apps/api:migrate:reset"]
+```
+
+## Local Infrastructure (Docker, manual)
+
+These tasks are manual development conveniences. They are not a test dependency:
+the default test suite must not require `infra:up`, and tests that need a live
+database belong to the opt-in `test:integration` task described in
+[validation-pipeline.md](validation-pipeline.md).
+
+```toml
+# apps/api/mise.toml
+[tasks."infra:up"]
+description = "Start local infrastructure (PostgreSQL, Redis, etc.)"
+run = "docker compose -f docker-compose.infra.yml up -d"
+
+[tasks."infra:down"]
+description = "Stop local infrastructure"
+run = "docker compose -f docker-compose.infra.yml down"
+
+[tasks."infra:logs"]
+description = "View infrastructure logs"
+run = "docker compose -f docker-compose.infra.yml logs -f"
+
+[tasks."infra:reset"]
+description = "Reset infrastructure (remove volumes)"
+run = "docker compose -f docker-compose.infra.yml down -v"
+```
+
+## Root-Level Infrastructure Tasks
+
+```toml
+# Root mise.toml
+[tasks."infra:up"]
+description = "Start all local infrastructure"
+depends = ["//apps/api:infra:up"]
+
+[tasks."infra:down"]
+description = "Stop all local infrastructure"
+depends = ["//apps/api:infra:down"]
+```

package/skills/oma-dev-workflow/resources/i18n-patterns.md

@@ -0,0 +1,63 @@
+# i18n Build Patterns
+
+Internationalization workflows for monorepos.
+
+## Shared i18n Package
+
+```toml
+# packages/i18n/mise.toml
+[tasks.build]
+description = "Build i18n files for all platforms"
+depends = ["build:web", "build:mobile"]
+
+[tasks."build:web"]
+description = "Build for web (next-intl JSON)"
+run = "bun scripts/build-web.js"
+
+[tasks."build:mobile"]
+description = "Build for mobile (Flutter ARB)"
+run = "bun scripts/build-mobile.js"
+
+[tasks.watch]
+description = "Watch for changes and rebuild"
+run = "bun scripts/watch.js"
+```
+
+## Usage in Apps
+
+```bash
+# Build i18n for all apps
+mise run //packages/i18n:build
+
+# Watch for changes during development
+mise run //packages/i18n:watch
+```
+
+## Web Integration
+
+```toml
+# apps/web/mise.toml
+[tasks.dev]
+description = "Start Next.js dev server"
+depends = ["//packages/i18n:build"]
+run = "bun dev"
+
+[tasks.build]
+description = "Production build"
+depends = ["//packages/i18n:build"]
+run = "bun run build"
+```
+
+## Mobile Integration
+
+```toml
+# apps/mobile/mise.toml
+[tasks."gen:l10n"]
+description = "Generate Flutter localizations"
+run = "flutter gen-l10n"
+
+[tasks.dev]
+description = "Run Flutter on device"
+depends = ["gen:l10n"]
+run = "flutter run"
+```