@cubis/foundry 0.3.64 → 0.3.65

package/workflows/workflows/agent-environment-setup/platforms/claude/workflows/backend.md

@@ -0,0 +1,70 @@
+---
+command: "/backend"
+description: "Drive backend architecture and implementation via backend specialist with API, data, and reliability focus."
+triggers: ["backend", "api", "service", "database", "performance"]
+---
+# Backend Workflow
+
+# CHANGED: routing contract — made workflow-to-agent and skill mapping explicit — prevents blind startup skill_search and keeps agent selection machine-readable.
+# CHANGED: output contract — replaced human-readable bullets with structured payload fields — allows downstream agents to consume workflow output without re-asking for context.
+
+## When to use
+Use this when backend architecture or service logic is primary.
+
+## Routing
+- Primary specialist: `@backend-specialist`
+- Add `@database-architect` for `schema`, `migration`, `query`, `index`, or `N+1` tasks.
+- Add `@security-auditor` for `auth`, `jwt`, `oauth`, `rbac`, `session`, or `secrets`.
+
+## Skill Routing
+- Primary skills: `api-designer`, `nodejs-best-practices`
+- Supporting skills (optional): `api-patterns`, `database-skills`, `secure-code-guardian`, `postman`
+- Primary skill route:
+  - api, endpoint, REST, route, openapi, swagger, spec, contract → `api-designer`
+  - backend, service, middleware, hono, fastify, node → `nodejs-best-practices`
+- Supporting skills:
+  - schema, migration, query, index, performance, N+1 → `database-skills`
+  - auth, jwt, rbac, oauth, session, secrets → `secure-code-guardian`
+  - postman, collection, environment → `postman`
+  - response format, pagination, versioning → `api-patterns`
+
+## Context notes
+- This workflow file, active platform rules, and selected agents/skills guide execution.
+- Attach logs, screenshots, failing output, and relevant paths when context is incomplete.
+
+## Workflow steps
+1. Ask specialist(s) for design and risk assessment.
+2. Validate contracts, data model, and failure handling.
+3. Implement backend changes with observability.
+4. Always update API docs: OpenAPI spec, Swagger UI route, and Stoplight Elements route/component.
+5. Run targeted tests and summarize rollout notes.
+
+## Verification
+- Run focused checks/tests for the changed scope.
+- Confirm no regressions in adjacent behavior.
+- Note any gaps that were not validated.
+
+## Output Contract
+```yaml
+BACKEND_WORKFLOW_RESULT:
+  primary_agent_id: "backend-specialist"
+  supporting_agent_ids: ["database-architect", "security-auditor"]
+  primary_skill_ids: ["api-designer", "nodejs-best-practices"]
+  supporting_skill_ids: ["api-patterns", "database-skills", "secure-code-guardian", "postman"]
+  contract_changes:
+    summary: "Describe contract deltas"
+    openapi_spec_path: null
+    swagger_ui_route: null
+    stoplight_route_or_component: null
+  data_impact:
+    migration_required: false
+    migration_notes: null
+  reliability_and_security:
+    observability_notes: "Summarize logging, tracing, metrics, and alerting impact"
+    security_notes: "Summarize auth, validation, and sensitive-data impact"
+  verification:
+    checks_run: ["<command-or-test>"]
+    gaps: []
+  next_handoff:
+    plan_handoff: null
+```

package/workflows/workflows/agent-environment-setup/platforms/claude/workflows/brainstorm.md

@@ -0,0 +1,56 @@
+---
+command: "/brainstorm"
+description: "Generate concrete solution options and tradeoffs before committing to implementation."
+triggers: ["idea", "brainstorm", "options", "tradeoff", "approach"]
+---
+# Brainstorm Workflow
+
+# CHANGED: routing — added explicit primary and supporting specialists — prevents route manifest fallback to orchestrator for ideation work.
+# CHANGED: output contract — converted free-form bullets into structured YAML — keeps option handoff machine-readable across platforms.
+
+## When to use
+Use this when requirements are still fluid and architecture choices are open.
+
+## Routing
+- Primary specialist: `@project-planner`
+- Scope and user-value framing: `@product-manager`
+- Technical tradeoff review: `@backend-specialist`
+
+## Context notes
+- This workflow file, active platform rules, and selected agents/skills guide execution.
+- Attach logs, screenshots, failing output, and relevant paths when context is incomplete.
+
+## Skill Routing
+- Primary skills: `brainstorming`, `feature-forge`
+- Supporting skills (optional): `plan-writing`
+
+## Workflow steps
+1. Restate problem, constraints, and success metrics.
+2. Produce 2-4 options with architecture shape.
+3. Compare complexity, risk, and implementation speed.
+4. Recommend one option and justify rejection of others.
+
+## Verification
+- Run focused checks/tests for the changed scope.
+- Confirm no regressions in adjacent behavior.
+- Note any gaps that were not validated.
+
+## Output Contract
+```yaml
+BRAINSTORM_WORKFLOW_RESULT:
+  primary_agent: project-planner
+  supporting_agents: [product-manager?, backend-specialist?]
+  primary_skills: [brainstorming, feature-forge]
+  supporting_skills: [plan-writing?]
+  options:
+    - id: <string>
+      summary: <string>
+      pros: [<string>]
+      cons: [<string>]
+      risks: [<string>]
+  recommended_option: <option-id>
+  known_unknowns: [<string>] | []
+  first_milestone: <string>
+  next_handoff:
+    plan_handoff: <PLAN_HANDOFF|null>
+```

package/workflows/workflows/agent-environment-setup/platforms/claude/workflows/create.md

@@ -0,0 +1,60 @@
+---
+command: "/create"
+description: "Implement feature work with minimal blast radius and clear verification checkpoints."
+triggers: ["create", "build", "implement", "feature", "develop"]
+---
+# Create Workflow
+
+# CHANGED: routing — added explicit implementation owners by domain — prevents fallback routing and clarifies which specialist leads execution.
+# CHANGED: output contract — converted free-form bullets into structured YAML — makes create results consumable by downstream workflows.
+# CHANGED: skill routing — added `skill-authoring` as the canonical support skill for skill package work — lets skill creation and repair route cleanly without blind startup search.
+
+## When to use
+Use this for net-new implementation after design is stable.
+
+## Routing
+- Primary coordinator: `@orchestrator`
+- Backend implementation: `@backend-specialist`
+- Frontend implementation: `@frontend-specialist`
+- Mobile implementation: `@mobile-developer`
+- Verification support: `@test-engineer`
+
+## Context notes
+- This workflow file, active platform rules, and selected agents/skills guide execution.
+- Attach logs, screenshots, failing output, and relevant paths when context is incomplete.
+
+## Skill Routing
+- Primary skills: `feature-forge`, `architecture-designer`
+- Supporting skills (optional): `skill-authoring`, `lint-and-validate`, `test-master`
+- If the task is creating or repairing a skill package, load `skill-authoring` directly before generic supporting skills.
+
+## Workflow steps
+1. Confirm target files and contracts.
+2. Implement smallest coherent increment.
+3. Validate behavior with focused tests.
+4. Capture remaining gaps and follow-ups.
+
+## Verification
+- Run focused checks/tests for the changed scope.
+- Confirm no regressions in adjacent behavior.
+- Note any gaps that were not validated.
+
+## Output Contract
+```yaml
+CREATE_WORKFLOW_RESULT:
+  primary_agent_id: "orchestrator"
+  supporting_agent_ids: ["backend-specialist", "frontend-specialist", "mobile-developer", "test-engineer"]
+  primary_skill_ids: ["feature-forge", "architecture-designer"]
+  supporting_skill_ids: ["lint-and-validate", "test-master"]
+  implemented_scope:
+    summary: "Describe the implemented increment"
+    changed_artifacts: ["<path-or-artifact>"]
+  behavioral_impact: ["Describe user-visible or system-level changes"]
+  verification:
+    checks_run: ["<command-or-test>"]
+    evidence: ["Describe the strongest verification evidence"]
+    gaps: []
+  follow_up_items: []
+  next_handoff:
+    plan_handoff: null
+```

package/workflows/workflows/agent-environment-setup/platforms/claude/workflows/database.md

@@ -0,0 +1,61 @@
+---
+command: "/database"
+description: "Design or review schema, queries, and migrations with performance and integrity controls."
+triggers: ["database", "sql", "schema", "migration", "index"]
+---
+# Database Workflow
+
+# CHANGED: output contract — converted free-form bullets into structured YAML — keeps schema and migration handoffs machine-readable across platforms.
+
+## When to use
+Use this when data modeling, query quality, migration safety, or database performance is core to the task.
+
+## Routing
+- Primary specialist: `@database-architect`
+- Backend integration: `@backend-specialist`
+- Verification support: `@test-engineer`
+- Core skill hub: `database-skills`
+- Companion skills: `database-design` (schema/migrations), `database-optimizer` (tuning/triage)
+- Mobile/local persistence companion: `drift-flutter`
+- Engine references are loaded on-demand through `database-skills` using `skill_validate` and targeted `skill_get_reference`.
+
+## Context notes
+- This workflow file, active platform rules, and selected agents/skills guide execution.
+- Attach logs, screenshots, failing output, and relevant paths when context is incomplete.
+
+## Skill Routing
+- Primary skills: `database-skills`, `database-design`
+- Supporting skills (optional): `database-optimizer`
+- Engine references: `postgres`, `mysql`, `vitess`, `neki`, `mongodb`, `sqlite`, `supabase`, `redis`
+
+## Workflow steps
+1. Confirm data shape, access patterns, and workload size.
+2. Choose track: `database-design` (schema/migrations), `database-optimizer` (tuning), or `database-skills` (engine wrappers).
+3. Choose engine wrapper and define index strategy.
+4. Define pagination strategy (keyset first, offset only if justified).
+5. Plan migration and rollback.
+6. Validate with query-plan evidence and production-risk notes.
+
+## Verification
+- Run focused checks/tests for the changed scope.
+- Confirm no regressions in adjacent behavior.
+- Note any gaps that were not validated.
+
+## Output Contract
+```yaml
+DATABASE_WORKFLOW_RESULT:
+  primary_agent_id: "database-architect"
+  supporting_agent_ids: ["backend-specialist", "test-engineer"]
+  primary_skill_ids: ["database-skills", "database-design"]
+  supporting_skill_ids: ["database-optimizer"]
+  schema_changes: ["Describe schema changes"]
+  indexing_plan: ["Describe indexes and rationale"]
+  pagination_plan: null
+  migration:
+    required: false
+    plan: ["Describe migration steps"]
+    rollback: ["Describe rollback steps"]
+  evidence:
+    query_plans: ["Summarize explain or engine-native plan evidence"]
+    validation_checks: ["<command-or-test>"]
+```

package/workflows/workflows/agent-environment-setup/platforms/claude/workflows/debug.md

@@ -0,0 +1,54 @@
+---
+command: "/debug"
+description: "Isolate root cause quickly and apply the smallest safe remediation with verification."
+triggers: ["debug", "bug", "error", "incident", "stack trace"]
+---
+# Debug Workflow
+
+# CHANGED: routing — added explicit debug ownership and supporting specialists — prevents route manifest fallback to orchestrator during bug work.
+# CHANGED: output contract — converted free-form bullets into structured YAML — makes root-cause handoff deterministic.
+
+## When to use
+Use this when behavior is failing or inconsistent.
+
+## Routing
+- Primary specialist: `@debugger`
+- Domain implementation support: `@backend-specialist`
+- Verification support: `@test-engineer`
+
+## Context notes
+- This workflow file, active platform rules, and selected agents/skills guide execution.
+- Attach logs, screenshots, failing output, and relevant paths when context is incomplete.
+
+## Skill Routing
+- Primary skills: `systematic-debugging`, `find-bugs`
+- Supporting skills (optional): `monitoring-expert`, `error-ux-observability`
+
+## Workflow steps
+1. Reproduce issue and collect evidence.
+2. Narrow fault domain and identify root cause.
+3. Apply focused fix with low regression risk.
+4. Verify resolution and monitor for recurrence.
+
+## Verification
+- Run focused checks/tests for the changed scope.
+- Confirm no regressions in adjacent behavior.
+- Note any gaps that were not validated.
+
+## Output Contract
+```yaml
+DEBUG_WORKFLOW_RESULT:
+  primary_agent: debugger
+  supporting_agents: [backend-specialist?, test-engineer?]
+  primary_skills: [systematic-debugging, find-bugs]
+  supporting_skills: [monitoring-expert?, error-ux-observability?]
+  reproduction:
+    steps: [<string>]
+    expected_vs_actual: <string>
+  root_cause: <string>
+  remediation:
+    summary: <string>
+    changed_artifacts: [<path-or-artifact>]
+  regression_checks: [<command or test>]
+  follow_up_items: [<string>] | []
+```

package/workflows/workflows/agent-environment-setup/platforms/claude/workflows/devops.md

@@ -0,0 +1,49 @@
+---
+command: "/devops"
+description: "Plan and execute deployment, CI/CD, and operational safety changes with rollback controls."
+triggers: ["devops", "deploy", "ci", "cd", "rollback", "infra"]
+---
+# DevOps Workflow
+
+# CHANGED: output contract — converted free-form bullets into structured YAML — keeps rollout and rollback planning machine-readable.
+
+## When to use
+Use this when deployment pipeline, infrastructure, or release execution is the main scope.
+
+## Routing
+- Primary specialist: `@devops-engineer`
+- Security checks: `@security-auditor`
+- Verification support: `@test-engineer`
+
+## Context notes
+- This workflow file, active platform rules, and selected agents/skills guide execution.
+- Attach logs, screenshots, failing output, and relevant paths when context is incomplete.
+
+## Skill Routing
+- Primary skills: `devops-engineer`, `sre-engineer`
+- Supporting skills (optional): `monitoring-expert`, `terraform-engineer`, `wrangler`
+
+## Workflow steps
+1. Confirm target environment and risk level.
+2. Define rollout and rollback strategy.
+3. Apply CI/CD or infra changes.
+4. Validate monitors/alerts and recovery path.
+
+## Verification
+- Run focused checks/tests for the changed scope.
+- Confirm no regressions in adjacent behavior.
+- Note any gaps that were not validated.
+
+## Output Contract
+```yaml
+DEVOPS_WORKFLOW_RESULT:
+  primary_agent: devops-engineer
+  supporting_agents: [security-auditor?, test-engineer?]
+  primary_skills: [devops-engineer, sre-engineer]
+  supporting_skills: [monitoring-expert?, terraform-engineer?, wrangler?]
+  deployment_plan: [<string>]
+  rollback_conditions: [<string>]
+  validation_checks: [<command or test>]
+  observability_checks: [<string>]
+  outstanding_operational_risks: [<string>] | []
+```

package/workflows/workflows/agent-environment-setup/platforms/claude/workflows/implement-track.md

@@ -0,0 +1,56 @@
+---
+command: "/implement-track"
+description: "Execute large work in milestones with explicit quality gates and status updates."
+triggers: ["track", "milestone", "delivery", "progress", "execution"]
+---
+# Implement Track Workflow
+
+# CHANGED: routing — added explicit milestone coordination owners — prevents generic fallback and clarifies who runs long execution tracks.
+# CHANGED: output contract — converted free-form bullets into structured YAML — keeps milestone state machine-readable for resumability.
+
+## When to use
+Use this for medium/large efforts where progress visibility is required.
+
+## Routing
+- Primary coordinator: `@orchestrator`
+- Milestone planning: `@project-planner`
+- Verification gates: `@test-engineer`
+
+## Context notes
+- This workflow file, active platform rules, and selected agents/skills guide execution.
+- Attach logs, screenshots, failing output, and relevant paths when context is incomplete.
+
+## Skill Routing
+- Primary skills: `plan-writing`, `feature-forge`
+- Supporting skills (optional): `lint-and-validate`, `test-master`
+
+## Workflow steps
+1. Split into milestone-sized deliverables.
+2. Define done criteria per milestone.
+3. Execute one milestone at a time.
+4. Validate before moving forward.
+5. Publish progress and remaining risks.
+
+## Verification
+- Run focused checks/tests for the changed scope.
+- Confirm no regressions in adjacent behavior.
+- Note any gaps that were not validated.
+
+## Output Contract
+```yaml
+IMPLEMENT_TRACK_WORKFLOW_RESULT:
+  primary_agent: orchestrator
+  supporting_agents: [project-planner?, test-engineer?]
+  primary_skills: [plan-writing, feature-forge]
+  supporting_skills: [lint-and-validate?, test-master?]
+  milestones:
+    done: [<string>]
+    in_progress: [<string>]
+    next: [<string>]
+  gate_status: [<string>]
+  blockers: [<string>] | []
+  dependencies: [<string>] | []
+  eta_confidence: <low|medium|high>
+  next_handoff:
+    plan_handoff: <PLAN_HANDOFF|null>
+```

package/workflows/workflows/agent-environment-setup/platforms/claude/workflows/incident.md

@@ -0,0 +1,52 @@
+---
+command: "/incident"
+description: "Handle production incidents with triage, mitigation, root cause, and post-incident actions."
+triggers: ["incident", "outage", "sev", "degraded", "hotfix"]
+---
+# Incident Workflow
+
+# CHANGED: output contract — converted free-form bullets into structured YAML — keeps incident mitigation and follow-up data structured for resumability.
+
+## When to use
+Use this for active or recent production incidents.
+
+## Routing
+- Runtime/service issues: `@backend-specialist` + `@debugger`
+- Data inconsistencies: `@database-architect`
+- Security events: `@security-auditor`
+- Recovery validation: `@test-engineer`
+- Deployment rollback execution: `@devops-engineer`
+
+## Context notes
+- This workflow file, active platform rules, and selected agents/skills guide execution.
+- Attach logs, screenshots, failing output, and relevant paths when context is incomplete.
+
+## Skill Routing
+- Primary skills: `systematic-debugging`, `sre-engineer`
+- Supporting skills (optional): `monitoring-expert`, `security-reviewer`
+
+## Workflow steps
+1. Establish impact, severity, and current status.
+2. Mitigate first, then stabilize.
+3. Identify probable root cause and confirm.
+4. Implement and verify durable fix.
+5. Document post-incident follow-up actions.
+
+## Verification
+- Run focused checks/tests for the changed scope.
+- Confirm no regressions in adjacent behavior.
+- Note any gaps that were not validated.
+
+## Output Contract
+```yaml
+INCIDENT_WORKFLOW_RESULT:
+  primary_agent_id: "backend-specialist"
+  escalation_agent_ids: ["debugger", "database-architect", "security-auditor", "test-engineer", "devops-engineer"]
+  primary_skill_ids: ["systematic-debugging", "sre-engineer"]
+  supporting_skill_ids: ["monitoring-expert", "security-reviewer"]
+  incident_timeline: ["Summarize sequence of impact, detection, mitigation, and recovery"]
+  mitigation_actions: ["Describe mitigation steps taken"]
+  root_cause: "Describe confirmed or best-supported root cause"
+  durable_fix: null
+  follow_up_prevention_tasks: ["Describe prevention and hardening actions"]
+```

package/workflows/workflows/agent-environment-setup/platforms/claude/workflows/mobile.md

@@ -0,0 +1,48 @@
+---
+command: "/mobile"
+description: "Drive mobile implementation decisions for Flutter/cross-platform behavior and reliability."
+triggers: ["mobile", "flutter", "ios", "android", "navigation"]
+---
+# Mobile Workflow
+
+# CHANGED: output contract — converted free-form bullets into structured YAML — keeps mobile flow changes and readiness notes machine-readable.
+
+## When to use
+Use this when mobile app architecture, UX behavior, or platform constraints are the focus.
+
+## Routing
+- Primary specialist: `@mobile-developer`
+- UI support: `@frontend-specialist`
+- Verification support: `@test-engineer`
+
+## Context notes
+- This workflow file, active platform rules, and selected agents/skills guide execution.
+- Attach logs, screenshots, failing output, and relevant paths when context is incomplete.
+
+## Skill Routing
+- Primary skills: `mobile-design`, `flutter-expert`
+- Supporting skills (optional): `riverpod-3`, `drift-flutter`, `flutter-test-master`
+
+## Workflow steps
+1. Confirm platform and UX constraints.
+2. Plan navigation/state/offline behavior.
+3. Implement or refactor mobile flows.
+4. Validate behavior across critical paths.
+
+## Verification
+- Run focused checks/tests for the changed scope.
+- Confirm no regressions in adjacent behavior.
+- Note any gaps that were not validated.
+
+## Output Contract
+```yaml
+MOBILE_WORKFLOW_RESULT:
+  primary_agent: mobile-developer
+  supporting_agents: [frontend-specialist?, test-engineer?]
+  primary_skills: [mobile-design, flutter-expert]
+  supporting_skills: [riverpod-3?, drift-flutter?, flutter-test-master?]
+  flow_changes: [<string>]
+  platform_constraints_handled: [<string>]
+  test_coverage_summary: [<string>]
+  release_readiness_notes: [<string>] | []
+```

package/workflows/workflows/agent-environment-setup/platforms/claude/workflows/orchestrate.md

@@ -0,0 +1,60 @@
+---
+command: "/orchestrate"
+description: "Coordinate multiple specialists to solve cross-cutting tasks with explicit ownership and handoff."
+triggers: ["orchestrate", "coordinate", "multi-area", "cross-team", "handoff"]
+---
+# Orchestrate Workflow
+
+# CHANGED: output contract — converted free-form bullets into structured YAML — keeps multi-workstream coordination deterministic across regenerated platforms.
+# CHANGED: skill routing — added `skill-authoring` when orchestration spans canonical skill edits, generator updates, and platform parity work.
+
+## When to use
+Use this when a task spans backend, frontend, data, testing, and release concerns.
+
+## Routing
+- Primary coordinator: `@orchestrator`
+- Architecture decisions: `@backend-specialist`
+- Data model/query risk: `@database-architect`
+- UX/client behavior: `@frontend-specialist`
+- Security review: `@security-auditor`
+- Verification strategy: `@test-engineer`
+- Rollout plan: `@devops-engineer`
+
+## Workflow steps
+1. Break the request into workstreams with owners.
+2. Request one primary specialist output per workstream.
+3. Merge outputs into a single implementation plan.
+4. Resolve conflicts before implementation.
+5. End with a release-risk summary.
+
+## Context notes
+- This workflow file, active platform rules, and selected agents/skills guide execution.
+- Attach logs, screenshots, failing output, and relevant paths when context is incomplete.
+
+## Skill Routing
+- Primary skills: `parallel-agents`, `architecture-designer`
+- Supporting skills (optional): `plan-writing`, `feature-forge`, `skill-authoring`
+- When the workstream includes skill package changes across multiple platforms, load `skill-authoring` as the first supporting skill.
+
+## Verification
+- Run focused checks/tests for the changed scope.
+- Confirm no regressions in adjacent behavior.
+- Note any gaps that were not validated.
+
+## Output Contract
+```yaml
+ORCHESTRATE_WORKFLOW_RESULT:
+  primary_agent: orchestrator
+  supporting_agents: [backend-specialist?, database-architect?, frontend-specialist?, security-auditor?, test-engineer?, devops-engineer?]
+  primary_skills: [parallel-agents, architecture-designer]
+  supporting_skills: [plan-writing?, feature-forge?]
+  scope_and_assumptions: [<string>]
+  workstreams:
+    - owner: <agent-id>
+      deliverable: <string>
+  execution_order: [<string>]
+  gates:
+    test: [<string>]
+    rollout: [<string>]
+  open_risks: [<string>] | []
+```

package/workflows/workflows/agent-environment-setup/platforms/claude/workflows/plan.md

@@ -0,0 +1,63 @@
+---
+command: "/plan"
+description: "Build a decision-complete implementation plan with interfaces, failure modes, and acceptance criteria."
+triggers: ["plan", "spec", "design", "roadmap", "acceptance"]
+---
+# Plan Workflow
+
+# CHANGED: output contract — upgraded to canonical PLAN_HANDOFF schema — lets implementation agents continue task 1→N without re-routing or user restatement.
+# CHANGED: skill routing — added `skill-authoring` as a planning support skill for skill package design and maintenance work.
+
+## When to use
+Use this when execution needs a stable specification.
+
+## Routing
+- Primary specialist: `@project-planner`
+- Scope clarification: `@product-manager`
+- Architecture review: `@backend-specialist`
+- Verification planning: `@test-engineer`
+
+## Context notes
+- This workflow file, active platform rules, and selected agents/skills guide execution.
+- Attach logs, screenshots, failing output, and relevant paths when context is incomplete.
+
+## Skill Routing
+- Primary skills: `plan-writing`, `architecture-designer`
+- Supporting skills (optional): `feature-forge`, `api-designer`, `skill-authoring`
+- When the plan itself is for a skill package, prefer `skill-authoring` as the first supporting skill.
+
+## Workflow steps
+1. Lock scope and non-goals.
+2. Define architecture, boundaries, and data flow.
+3. Specify interfaces and validation rules.
+4. Document failure modes and mitigations.
+5. Define tests and release acceptance criteria.
+
+## Verification
+- Run focused checks/tests for the changed scope.
+- Confirm no regressions in adjacent behavior.
+- Note any gaps that were not validated.
+
+## Output Contract
+```yaml
+PLAN_HANDOFF:
+  tasks:
+    - id: 1
+      title: "Describe the first implementation task"
+      domain: "backend"
+      skill_hint: "api-designer"
+      depends_on: []
+      output_artifact: "path-or-artifact"
+      stop_if_failed: true
+  shared_context:
+    stack: "Describe the target stack"
+    constraints: "List hard requirements and guardrails"
+    active_files: ["path-or-artifact"]
+  execution_mode: "sequential"
+  loaded_skills: ["api-designer"]
+  stop_conditions:
+    - "output_artifact missing AND stop_if_failed: true"
+    - "destructive or irreversible action not in plan"
+    - "required skill missing after 1 skill_search attempt"
+    - "explicit user pause or redirect"
+```