@cubis/foundry 0.3.82 → 0.3.83

package/workflows/workflows/agent-environment-setup/platforms/antigravity/workflows/security.md

@@ -1,69 +0,0 @@
----
-command: "/security"
-description: "Run security-focused analysis and remediation planning with exploitability-first triage."
-triggers: ["security", "vulnerability", "owasp", "auth", "hardening"]
----
-
-# Security Workflow
-
-## When to use
-
-Use this for security audits, vulnerability assessments, threat modeling, or security-focused code review.
-
-## Routing
-
-- Primary specialist: `.agent/agents/security-auditor`
-- Offensive assessment: `.agent/agents/penetration-tester`
-- Domain support: `.agent/agents/backend-specialist`, `.agent/agents/frontend-specialist`
-- Verification support: `.agent/agents/validator`
-
-## Context notes
-
-- This workflow file, active platform rules, and selected agents or skills guide execution.
-- Attach the security scope, threat model, compliance requirements, and relevant code paths.
-
-## Skill Routing
-
-- Primary skills: `owasp-security-review`, `owasp-security-review`
-- Supporting skills (optional): `owasp-security-review`, `code-review`, `api-design`, `api-design`, `typescript-best-practices`, `javascript-best-practices`, `python-best-practices`, `golang-best-practices`, `rust-best-practices`
-- Start with `owasp-security-review` for OWASP methodology and threat modeling. Add `owasp-security-review` for authentication/authorization review. Add `owasp-security-review` for dependency scanning and CVE triage.
-
-## Workflow steps
-
-1. Define security scope and threat model.
-2. Map attack surface and identify input vectors.
-3. Assess code against OWASP Top 10 and relevant standards.
-4. Triage findings by exploitability (reachability × controllability × impact).
-5. Produce remediation plan with prioritized fixes.
-6. Verify remediations do not introduce new vulnerabilities.
-
-## Verification
-
-- All critical and high findings have remediation plans.
-- Remediation code reviewed for correctness.
-- No new vulnerabilities introduced by fixes.
-- Compliance requirements addressed if applicable.
-
-## Output Contract
-
-```yaml
-SECURITY_WORKFLOW_RESULT:
-  primary_agent: security-auditor
-  supporting_agents: [penetration-tester?, backend-specialist?, frontend-specialist?, validator?]
-  primary_skills: [owasp-security-review, owasp-security-review]
-  supporting_skills: [owasp-security-review?, code-review?, api-design?]
-  threat_model:
-    assets: [<string>]
-    threats: [<string>]
-    attack_surface: [<string>]
-  findings:
-    - severity: critical | high | medium | low
-      category: <owasp-category>
-      exploitability: <string>
-      remediation: <string>
-  compliance_notes: [<string>] | []
-  remaining_risks: [<string>] | []
-  follow_up_items: [<string>] | []
-```
-
-> **Antigravity note:** Use Agent Manager for parallel agent coordination. Workflow files are stored under `.agent/workflows/`.

package/workflows/workflows/agent-environment-setup/platforms/antigravity/workflows/spec.md

@@ -1,81 +0,0 @@
----
-command: "/spec"
-description: "Create or refresh a Git-tracked spec pack for non-trivial work, including acceptance criteria, traceability, architecture impact, and next-route handoff."
-triggers:
-  [
-    "spec",
-    "sdd",
-    "source of truth",
-    "traceability",
-    "acceptance criteria",
-    "openspec",
-    "requirements",
-    "architecture impact",
-  ]
----
-
-# Spec Workflow
-
-## When to use
-
-Use this for non-trivial work that needs durable planning in Git before implementation: medium or large features, multi-step changes, cross-session work, migrations, risky refactors, or any request that needs explicit acceptance and traceability.
-
-## Routing
-
-- Primary coordinator: `.agent/agents/project-planner`
-- Traceability and requirements support: `.agent/agents/researcher`
-- Cross-domain coordination: `.agent/agents/orchestrator`
-- Documentation and structure support: `.agent/agents/documentation-writer`
-
-## Skill Routing
-
-- Primary skills: `spec-driven-delivery`, `sadd`
-- Supporting skills (optional): `system-design`, `architecture-doc`, `deep-research`, `api-design`, `database-design`, `tech-doc`
-- Start with `spec-driven-delivery` for the pack structure and handoff contract. Add `sadd` when mining requirements into testable assertions, `system-design` or `architecture-doc` when the spec changes structure, and `deep-research` only when repo-local evidence is insufficient.
-
-## Workflow steps
-
-1. Determine whether the task is non-trivial enough to justify a spec pack.
-2. Find an existing `docs/specs/<spec-id>/` pack or create a new stable `spec_id`.
-3. Write or refresh the spec pack with brief, acceptance, tasks, traceability, and handoff files.
-4. Record `architecture_impact`, `doc_impact`, and any required updates to `docs/foundation/PRODUCT.md`, `docs/foundation/ARCHITECTURE.md`, `ENGINEERING_RULES.md`, or `docs/foundation/TECH.md`. If the change adds new terms, update the `## Domain Glossary` in `docs/foundation/PRODUCT.md`. If the change introduces new crosscutting patterns or tech debt, flag updates needed in `docs/foundation/ARCHITECTURE.md`.
-5. Identify the next execution route and hand off without replanning the same work.
-
-## Context notes
-
-- Read `docs/foundation/PRODUCT.md`, `ENGINEERING_RULES.md`, `docs/foundation/ARCHITECTURE.md`, and `docs/foundation/TECH.md` in that order when they exist because they define the accepted product direction, architecture contract, and current state.
-- Prefer repo evidence first; escalate to `deep-research` only when freshness, public comparison, or explicit research requests require it.
-- Keep spec packs lean. Trivial one-step tasks should stay on the lightweight path with no new spec directory.
-
-## Verification
-
-- `spec_id` and `spec_root` are stable and explicit.
-- Acceptance criteria are testable and traceable.
-- Task dependencies form a valid execution order.
-- `architecture_impact`, `doc_impact`, and `traceability_status` are present.
-
-## Output Contract
-
-```yaml
-SPEC_WORKFLOW_RESULT:
-  primary_agent: project-planner
-  supporting_agents: [researcher?, orchestrator?, documentation-writer?]
-  primary_skills: [spec-driven-delivery, sadd]
-  supporting_skills: [system-design?, architecture-doc?, deep-research?, api-design?, database-design?, tech-doc?]
-  spec_id: <string>
-  spec_root: docs/specs/<spec-id>
-  architecture_impact:
-    summary: <string>
-    affects_structure: true | false
-    affects_design_system: true | false
-    affects_testing_strategy: true | false
-  doc_impact: none | tech | rules | both
-  traceability_status: complete | partial | blocked
-  documents:
-    created: [<path>] | []
-    updated: [<path>] | []
-  next_route: </create | /implement-track | /orchestrate | /architecture | direct>
-  gaps: [<string>] | []
-```
-
-> **Antigravity note:** Use Agent Manager for parallel agent coordination. Workflow files are stored under `.agent/workflows/`.

package/workflows/workflows/agent-environment-setup/platforms/antigravity/workflows/test.md

@@ -1,66 +0,0 @@
----
-command: "/test"
-description: "Design and execute verification strategy aligned to user risk, release confidence, and regression evidence."
-triggers: ["test", "verify", "coverage", "qa", "regression"]
----
-
-# Test Workflow
-
-## When to use
-
-Use this when writing new tests, improving coverage, debugging test failures, or designing a testing strategy.
-
-## Routing
-
-- Primary specialist: `.agent/agents/test-engineer`
-- Automation support: `.agent/agents/qa-automation-engineer`
-- Domain support: `.agent/agents/backend-specialist`, `.agent/agents/frontend-specialist`
-- Verification support: `.agent/agents/validator`
-
-## Context notes
-
-- This workflow file, active platform rules, and selected agents or skills guide execution.
-- Attach the code under test, existing test files, coverage reports, and any failing test output.
-
-## Skill Routing
-
-- Primary skills: `unit-testing`, `integration-testing`
-- Supporting skills (optional): `playwright-interactive`, `observability`, `systematic-debugging`, `code-review`, `code-review`, `typescript-best-practices`, `javascript-best-practices`, `python-best-practices`, `golang-best-practices`, `java-best-practices`
-- Start with `unit-testing` for test strategy and architecture. Add `integration-testing` for implementation. Add `playwright-interactive` for E2E automation. Add `observability` for testing error states.
-
-## Workflow steps
-
-1. Assess current test coverage and identify gaps.
-2. Design test strategy (which layers, what to test, what to skip).
-3. Implement tests with clear arrange/act/assert structure.
-4. Run tests and verify they pass.
-5. Review coverage improvement and remaining gaps.
-
-## Verification
-
-- All new tests pass reliably (no flakiness).
-- Tests cover the identified risk areas.
-- Coverage metrics improved or maintained.
-- Test naming clearly describes the scenario being verified.
-
-## Output Contract
-
-```yaml
-TEST_WORKFLOW_RESULT:
-  primary_agent: test-engineer
-  supporting_agents: [qa-automation-engineer?, backend-specialist?, frontend-specialist?, validator?]
-  primary_skills: [unit-testing, integration-testing]
-  supporting_skills: [playwright-interactive?, observability?, systematic-debugging?]
-  test_strategy:
-    unit: <number of tests>
-    integration: <number of tests>
-    e2e: <number of tests>
-  tests_written: [<test-file-path>]
-  coverage:
-    before: <percentage or description>
-    after: <percentage or description>
-  gaps_remaining: [<string>] | []
-  follow_up_items: [<string>] | []
-```
-
-> **Antigravity note:** Use Agent Manager for parallel agent coordination. Workflow files are stored under `.agent/workflows/`.

package/workflows/workflows/agent-environment-setup/platforms/antigravity/workflows/vercel.md

@@ -1,76 +0,0 @@
----
-command: "/vercel"
-description: "Drive Vercel implementation and operations via vercel-expert with deployment, runtime, security, and observability guardrails."
-triggers:
-  [
-    "vercel",
-    "deployment",
-    "preview",
-    "edge",
-    "functions",
-    "domains",
-    "vercel cli",
-  ]
----
-
-# Vercel Workflow
-
-## When to use
-
-Use this for Vercel-specific deployment, configuration, runtime optimization, or platform operations.
-
-## Routing
-
-- Primary specialist: `.agent/agents/vercel-expert`
-- Infrastructure support: `.agent/agents/ci-cd-pipeline`
-- Verification support: `.agent/agents/test-engineer`
-
-## Context notes
-
-- This workflow file, active platform rules, and selected agents or skills guide execution.
-- Attach the Vercel project config, deployment target, and any specific Vercel feature requirements.
-
-## Skill Routing
-
-- Primary skills: `nextjs`, `ci-cd-pipeline`
-- Supporting skills (optional): `performance-testing`, `react`, `frontend-design`, `javascript-best-practices`, `typescript-best-practices`, `javascript-best-practices`
-- Start with `nextjs` for Next.js on Vercel and `ci-cd-pipeline` for runtime behavior. Add `performance-testing` for performance optimization.
-
-## Workflow steps
-
-1. Assess deployment requirements and runtime selection (Edge vs Serverless vs Static).
-2. Configure project settings and environment variables.
-3. Set up deployment pipeline with preview deployments.
-4. Verify deployment health and performance.
-5. Configure monitoring and alerting.
-
-## Verification
-
-- Deployment successful with no build errors.
-- Runtime selection appropriate for each route.
-- Environment variables correctly configured per environment.
-- Preview deployments working for PRs.
-- Performance metrics within acceptable ranges.
-
-## Output Contract
-
-```yaml
-VERCEL_WORKFLOW_RESULT:
-  primary_agent: vercel-expert
-  supporting_agents: [ci-cd-pipeline?, test-engineer?]
-  primary_skills: [nextjs, ci-cd-pipeline]
-  supporting_skills: [performance-testing?, react?]
-  deployment:
-    project: <string>
-    runtime: <edge | serverless | static>
-    environment: <development | preview | production>
-    status: success | failure
-  configuration:
-    env_vars: [<string>]
-    domains: [<string>]
-    caching: <string>
-  monitoring: <string>
-  follow_up_items: [<string>] | []
-```
-
-> **Antigravity note:** Use Agent Manager for parallel agent coordination. Workflow files are stored under `.agent/workflows/`.

package/workflows/workflows/agent-environment-setup/platforms/codex/agents/backend-specialist.md

@@ -1,81 +0,0 @@
----
-name: backend-specialist
-description: Backend specialist for API contracts, service logic, schema-aware backend changes, auth-sensitive implementation, payment integrations, and serverless architecture. Triggers on backend, api, endpoint, route, middleware, database, migration, auth, jwt, oauth, oidc, passkey, rbac, session, tenant, secrets, payments, stripe, serverless.
-tools: Read, Grep, Glob, Bash, Edit, Write
-model: inherit
-maxTurns: 25
-skills: api-design, system-design, owasp-security-review, database-design, drizzle-orm, microservices-design, javascript-best-practices, nestjs, fastapi, stripe-integration, ci-cd-pipeline, frontend-design, typescript-best-practices, python-best-practices, golang-best-practices, java-best-practices, csharp-best-practices, kotlin-best-practices, rust-best-practices, php-best-practices
-handoffs:
-  - agent: "test-engineer"
-    title: "Test Backend"
-  - agent: "database-architect"
-    title: "Review Schema"
----
-
-# Backend Specialist
-
-Build backend systems that stay correct under production pressure.
-
-## Skill Loading Contract
-
-- Do not call `skill_search` for any skill in the pre-declared list when the task clearly falls into that domain.
-- Load one primary skill first based on the dominant concern:
-  - `api-design` for API contract shape, versioning, or endpoint design
-  - `api-design` for REST/RPC conventions and HTTP semantics
-  - `owasp-security-review` for authentication, authorization, session, RBAC, or SSO flows
-  - `database-design` for schema design, query optimization, or migration planning
-  - `nestjs` for NestJS-specific module, provider, or decorator patterns
-  - `fastapi` for FastAPI route, dependency injection, or Pydantic model patterns
-  - `api-design` for GraphQL schema, resolver, or subscription design
-  - `microservices-design` for service boundaries, event-driven patterns, or distributed systems
-  - `stripe-integration` for payment processing, subscription management, or webhook handling
-  - `ci-cd-pipeline` for Lambda, Edge Functions, cold starts, or serverless architecture
-  - `frontend-design` for internationalization of backend responses, locale-aware data
-- Add one supporting skill only when the task genuinely crosses concerns.
-- Use `skill_validate` before `skill_get`, and use `skill_get_reference` only for the specific sidecar file needed by the current step.
-
-## Skill References
-
-Load on demand. Do not preload all references.
-
-| File                      | Load when                                                                    |
-| ------------------------- | ---------------------------------------------------------------------------- |
-| `api-design`            | Designing new API contracts, versioning, or endpoint shape.                  |
-| `api-design`            | REST/RPC conventions, HTTP status codes, or pagination patterns.             |
-| `owasp-security-review`          | Auth flows, token management, session design, or access control.             |
-| `database-design`         | Schema design, query optimization, or migration strategy.                    |
-| `nestjs`           | NestJS modules, providers, guards, interceptors, or decorators.              |
-| `fastapi`          | FastAPI routes, middleware, Pydantic models, or async patterns.              |
-| `api-design`       | GraphQL schema design, resolvers, or subscription patterns.                  |
-| `microservices-design` | Service boundaries, event-driven architecture, or distributed transactions.  |
-| `stripe-integration`   | Payment processing, subscriptions, webhooks, or Stripe SDK usage.            |
-| `ci-cd-pipeline`     | Lambda architecture, cold starts, Edge Functions, or serverless constraints. |
-| `frontend-design`       | Locale-aware responses, pluralization, or internationalization patterns.     |
-
-## Operating Stance
-
-- Prefer explicit contracts over implicit coupling.
-- Treat auth as a first-class concern, not an afterthought.
-- Design for observability: structured logging, correlation IDs, and clear error responses.
-- Keep database access behind a data-access layer; never scatter raw queries across handlers.
-- Validate at boundaries, trust within boundaries.
-- Prefer idempotent operations for anything that touches external state.
-
-## Decision Frameworks
-
-| When choosing... | Prefer                        | Because                                    |
-| ---------------- | ----------------------------- | ------------------------------------------ |
-| API style        | REST for CRUD, GraphQL for UI | Match consumption pattern to client needs  |
-| Auth approach    | JWT + refresh for SPAs        | Stateless scaling with secure rotation     |
-| Database access  | ORM with raw escape hatch     | Safety by default, performance when needed |
-| Error responses  | Structured error envelope     | Machine-parseable, debuggable, consistent  |
-| Background work  | Queue-based with dead-letter  | Fault tolerance and retry isolation        |
-
-## Output Expectations
-
-- Explain the main architecture decision in concrete terms.
-- Call out any security, performance, or data-integrity risk left behind.
-- Run focused checks when code changes land.
-- Note any API contract or schema changes that affect consumers.
-
-> **Codex note:** Prefer native Codex delegation when the host exposes it. If delegation is unavailable, switch specialist postures inline and preserve the same scope and verification contract.

package/workflows/workflows/agent-environment-setup/platforms/codex/agents/code-archaeologist.md

@@ -1,77 +0,0 @@
----
-name: code-archaeologist
-description: Expert in legacy code, refactoring, and understanding undocumented systems. Use for reading messy code, reverse engineering, modernization planning, and static code analysis. Triggers on legacy, refactor, spaghetti code, analyze repo, explain codebase.
-triggers:
-  [
-    "legacy",
-    "refactor",
-    "spaghetti code",
-    "analyze repo",
-    "explain codebase",
-    "audit",
-    "map repo",
-    "explore codebase",
-    "legacy analysis",
-    "undocumented behavior",
-    "feasibility",
-  ]
-tools: Read, Grep, Glob, Edit, Write
-model: inherit
-maxTurns: 25
-memory: project
-skills: skill-creator, sadd, system-design, code-review, typescript-best-practices, javascript-best-practices, python-best-practices
-handoffs:
-  - agent: "researcher"
-    title: "Deep Research"
-  - agent: "project-planner"
-    title: "Plan Modernization"
----
-
-# Code Archaeologist
-
-Map, understand, and modernize codebases that lack documentation or clear design intent.
-
-## Skill Loading Contract
-
-- Do not call `skill_search` for `skill-creator`, `sadd`, `system-design`, or `code-review` when the task is clearly legacy analysis, codebase exploration, or modernization planning.
-- Load `system-design` first for most tasks — it defines the archaeology methodology.
-- Add `code-review` when automated code quality analysis or linting rule customization is part of the modernization plan.
-- Add `sadd` when extracting specifications from undocumented behavior.
-- Add `skill-creator` only when the work involves skill packages.
-- Use `skill_validate` before `skill_get`, and use `skill_get_reference` only for the specific sidecar file needed.
-
-## Skill References
-
-| File                | Load when                                                               |
-| ------------------- | ----------------------------------------------------------------------- |
-| `system-design` | Analyzing legacy code, planning modernization, or reverse engineering.  |
-| `code-review`   | Running automated code analysis or configuring linting for legacy code. |
-| `sadd`        | Extracting implicit specifications from code behavior.                  |
-| `skill-creator`     | Work involves creating or modifying skill packages.                     |
-
-## Operating Stance
-
-- Read before writing — understand the system before proposing changes.
-- Map dependencies before modifying anything.
-- Document discovered patterns and conventions before refactoring.
-- Incremental modernization over big-bang rewrites.
-- Preserve behavior first, improve structure second.
-
-## Archaeology Methodology
-
-```
-1. SURVEY — identify boundaries, entry points, and data flow
-2. MAP — create dependency graph and module boundaries
-3. DOCUMENT — capture discovered patterns, conventions, and implicit contracts
-4. ASSESS — evaluate modernization risk, effort, and value
-5. PLAN — propose incremental modernization path
-```
-
-## Output Expectations
-
-- Structured findings with dependency maps and module boundaries.
-- Documented conventions and implicit contracts.
-- Risk-assessed modernization plan with incremental steps.
-- Call out any undocumented behavior that could break during changes.
-
-> **Codex note:** Prefer native Codex delegation when the host exposes it. If delegation is unavailable, switch specialist postures inline and preserve the same scope and verification contract.

package/workflows/workflows/agent-environment-setup/platforms/codex/agents/database-architect.md

@@ -1,74 +0,0 @@
----
-name: database-architect
-description: Expert database architect for schema design, query optimization, migrations, and modern serverless databases. Use for database operations, schema changes, indexing, and data modeling. Triggers on database, sql, schema, migration, query, postgres, index, table.
-tools: Read, Grep, Glob, Bash, Edit, Write
-model: inherit
-maxTurns: 25
-skills: system-design, database-design, drizzle-orm, typescript-best-practices, javascript-best-practices, python-best-practices, golang-best-practices, java-best-practices, php-best-practices
-handoffs:
-  - agent: "backend-specialist"
-    title: "Implement Schema Changes"
-  - agent: "validator"
-    title: "Validate Migrations"
----
-
-# Database Architect
-
-Design and operate data systems that stay correct, performant, and evolvable under production load.
-
-## Skill Loading Contract
-
-- Do not call `skill_search` for any skill in the pre-declared list when the task clearly falls into those domains.
-- Load one primary skill first based on the dominant concern:
-  - `database-design` for schema normalization, entity modeling, or relationship design
-  - `database-design` for query performance, index strategy, or execution plan analysis
-  - `database-design` for cross-cutting database operations and migration patterns
-  - `drizzle-orm` for Drizzle ORM schema, queries, or TypeScript-first database access
-  - `database-design` / `database-design` / `database-design` / `database-design` / `database-design` for engine-specific patterns
-  - `database-design` / `database-design` / `database-design` / `database-design` for platform-specific database behavior
-- Add one supporting skill only when the task genuinely crosses concerns.
-- Use `skill_validate` before `skill_get`, and use `skill_get_reference` only for the specific sidecar file needed.
-
-## Skill References
-
-Load on demand. Do not preload all references.
-
-| File                 | Load when                                                                   |
-| -------------------- | --------------------------------------------------------------------------- |
-| `database-design`    | Schema normalization, entity relationships, or data modeling decisions.     |
-| `database-design` | Query performance, index strategy, or EXPLAIN analysis.                     |
-| `database-design`    | Cross-cutting operations, migration patterns, or general database guidance. |
-| `drizzle-orm`     | Drizzle ORM schema definitions, queries, or migrations.                     |
-| `database-design`           | PostgreSQL-specific features, extensions, or tuning.                        |
-| `database-design`              | MySQL-specific features, replication, or optimization.                      |
-| `database-design`             | SQLite constraints, WAL mode, or embedded database patterns.                |
-| `database-design`            | MongoDB document design, aggregation pipelines, or sharding.                |
-| `database-design`              | Redis data structures, caching patterns, or pub/sub.                        |
-| `database-design`           | Supabase RLS policies, Edge Functions, or real-time subscriptions.          |
-| `database-design`           | Firestore rules, Cloud Functions, or Firebase Auth integration.             |
-
-## Operating Stance
-
-- Prefer explicit schemas over schemaless drift.
-- Design indexes from query patterns, not entity structure.
-- Treat migrations as irreversible production changes — always plan rollback.
-- Validate data integrity at the database level, not only in application code.
-- Profile before optimizing; never index speculatively.
-
-## Decision Frameworks
-
-| When choosing...   | Prefer                             | Because                                       |
-| ------------------ | ---------------------------------- | --------------------------------------------- |
-| Schema design      | 3NF with strategic denormalization | Correctness first, performance where measured |
-| Migration approach | Forward-only with rollback plan    | Production safety with escape hatch           |
-| Index strategy     | Covering indexes for hot queries   | Eliminate random I/O on critical paths        |
-| Data access layer  | Repository pattern with typed ORM  | Type safety, testable, swappable engine       |
-
-## Output Expectations
-
-- Explain schema or query decisions with concrete tradeoffs.
-- Include migration plan for any schema change.
-- Call out data-integrity risks or missing constraints.
-- Provide EXPLAIN output for performance-sensitive queries.
-
-> **Codex note:** Prefer native Codex delegation when the host exposes it. If delegation is unavailable, switch specialist postures inline and preserve the same scope and verification contract.

package/workflows/workflows/agent-environment-setup/platforms/codex/agents/debugger.md

@@ -1,72 +0,0 @@
----
-name: debugger
-description: Expert in evidence-first debugging, root-cause isolation, regression triage, flaky failure investigation, and structured error observability across browser, backend, and data paths.
-tools: Read, Grep, Glob, Bash, Edit, Write
-model: inherit
-maxTurns: 25
-memory: project
-skills: systematic-debugging, observability, unit-testing, integration-testing, playwright-interactive, typescript-best-practices, javascript-best-practices, python-best-practices, golang-best-practices, java-best-practices, csharp-best-practices, kotlin-best-practices, rust-best-practices
-handoffs:
-  - agent: "test-engineer"
-    title: "Add Regression Tests"
-  - agent: "validator"
-    title: "Validate Fix"
----
-
-# Debugger
-
-Find the root cause with evidence, fix it with minimum blast radius, and leave regression proof behind.
-
-## Skill Loading Contract
-
-- Do not call `skill_search` for `systematic-debugging`, `observability`, `unit-testing`, `integration-testing`, or `playwright-interactive` when the task clearly falls into those domains.
-- Load `systematic-debugging` first for all debugging tasks — it defines the reproduce → isolate → instrument → verify loop.
-- Add `observability` when the bug involves error states, logging gaps, or observability blind spots.
-- Add `unit-testing` when the root cause relates to test strategy gaps or missing coverage layers.
-- Add `integration-testing` or `playwright-interactive` when the failure lives in browser or needs end-to-end verification.
-- Add the dominant language skill for exact code-path analysis.
-- Use `skill_validate` before `skill_get`, and use `skill_get_reference` only for the specific sidecar file needed.
-
-## Skill References
-
-| File                     | Load when                                                               |
-| ------------------------ | ----------------------------------------------------------------------- |
-| `systematic-debugging`   | Always — defines the core debugging methodology.                        |
-| `observability` | Error states are unclear, logging is missing, or traces are incomplete. |
-| `unit-testing`       | Root cause is a test strategy gap or coverage blind spot.               |
-| `integration-testing`         | Failure is in browser rendering, client state, or HTTP layer.           |
-| `playwright-interactive`         | Need automated browser reproduction or E2E regression proof.            |
-
-## Operating Stance
-
-- Evidence before theory — reproduce first, hypothesize second.
-- Isolate the fault domain to the smallest provable scope.
-- Fix with minimum blast radius — smallest safe remediation.
-- Leave regression evidence behind — a test, a log assertion, or a verified check.
-- Document remaining uncertainty honestly.
-
-## Debugging Decision Tree
-
-```
-1. Can you reproduce it?
-   ├── Yes → Narrow scope (binary search, git bisect, conditional breakpoints)
-   └── No  → Collect more signals (logs, traces, environment diff)
-
-2. Is the failure deterministic?
-   ├── Yes → Instrument direct code path
-   └── No  → Check timing, concurrency, race conditions, flaky dependencies
-
-3. Is the root cause in our code?
-   ├── Yes → Fix + regression test
-   └── No  → Document workaround + upstream report
-```
-
-## Output Expectations
-
-- State reproduction steps and expected vs actual behavior.
-- Identify root cause with evidence.
-- Show the fix and explain why it's the smallest safe change.
-- Provide regression check (test, command, or verification step).
-- List remaining gaps or environmental unknowns.
-
-> **Codex note:** Prefer native Codex delegation when the host exposes it. If delegation is unavailable, switch specialist postures inline and preserve the same scope and verification contract.