@ryuenn3123/agentic-senior-core 1.8.0 → 1.8.1

package/.agent-context/skills/distribution/README.md

@@ -0,0 +1,19 @@
+# Distribution Engineering Skills
+
+Default tier: `expert`
+
+This domain governs release packaging, compatibility policy, and rollback readiness.
+
+## Topics
+- [Publish Hygiene](publish.md) - Package integrity, provenance, and release evidence
+- [Rollback](rollback.md) - Recovery-first release operations
+- [Compatibility](compatibility.md) - Runtime/tooling support policy and guardrails
+
+## Operating Model
+- Use `expert` as the default distribution tier.
+- Block release if rollback and compatibility guarantees are not verified.
+
+## Above-Line Additions
+- Release gates tied to benchmark and compatibility checks.
+- Supply-chain artifacts (SBOM/provenance) as first-class outputs.
+- Explicit rollback drills before critical releases.

package/.agent-context/skills/distribution/compatibility.md

@@ -0,0 +1,32 @@
+# Compatibility
+
+Tier: ADVANCE
+
+Compatibility policy prevents shipping builds that break on supported runtimes or tooling ecosystems.
+
+## Compatibility Matrix
+
+Define supported combinations explicitly:
+- Runtime versions (Node, Python, Java, etc.)
+- OS/platform scope
+- IDE/editor integration versions
+- Dependency constraints
+
+## Gate Strategy
+
+- Validate package against supported runtime matrix in CI.
+- Block release on unsupported runtime regressions.
+- Mark deprecated support windows and removal timeline.
+
+## Breaking Change Protocol
+
+- Major version for incompatible behavior.
+- Migration notes for changed defaults.
+- Transitional compatibility period when feasible.
+
+## Review Checklist
+
+- [ ] Supported runtime matrix is current and tested.
+- [ ] Incompatible changes are versioned correctly.
+- [ ] Migration notes exist for user-impacting changes.
+- [ ] CI verifies compatibility before publish.

package/.agent-context/skills/distribution/publish.md

@@ -0,0 +1,37 @@
+# Publish Hygiene
+
+Tier: EXPERT
+
+Publishing should be repeatable, auditable, and minimal in surface area.
+
+## Pre-Publish Gates
+
+- Validate package contents and metadata.
+- Run tests and policy validators.
+- Confirm version/changelog consistency.
+- Generate SBOM and provenance artifacts.
+
+## Package Surface Control
+
+- Use explicit allow-list for publish files.
+- Exclude internal scripts, test fixtures, and local configs.
+- Verify CLI entry points and executable permissions.
+
+## Ownership and Provenance
+
+- Ensure publisher identity is controlled.
+- Record commit SHA and release timestamp.
+- Attach generated reports (gate, benchmark, SBOM) to release artifacts.
+
+## Failure Policy
+
+- Abort publish on failing quality gate.
+- Abort publish on unresolved high-severity security findings.
+- Abort publish on missing changelog entry.
+
+## Review Checklist
+
+- [ ] Package contents match expected release manifest.
+- [ ] Quality and security gates passed.
+- [ ] Version and changelog are aligned.
+- [ ] Provenance artifacts are generated and stored.

package/.agent-context/skills/distribution/rollback.md

@@ -0,0 +1,32 @@
+# Rollback
+
+Tier: EXPERT
+
+Rollback is a mandatory release capability, not an afterthought.
+
+## Rollback Readiness
+
+- Define rollback trigger conditions before release.
+- Keep previous stable artifact available for immediate redeploy.
+- Preserve migration rollback scripts for data-affecting changes.
+
+## Rollback Flow
+
+1. Detect failure signal (error spike, failed SLO, functional regression).
+2. Freeze new rollout.
+3. Re-deploy previous known-good version.
+4. Verify health checks and key journeys.
+5. Publish incident summary with root-cause owner.
+
+## Data Change Safety
+
+- Use backward-compatible migrations for forward and rollback paths.
+- Avoid destructive schema operations in same release as code cutover.
+- Validate rollback on staging with production-like data shape.
+
+## Review Checklist
+
+- [ ] Rollback plan documented and tested.
+- [ ] Previous release artifact retained.
+- [ ] Data migration rollback path verified.
+- [ ] Health checks confirm rollback success.

package/.agent-context/skills/distribution.md

@@ -0,0 +1,29 @@
+# Distribution Skill Pack
+
+Default tier: `expert`
+
+## Purpose
+Protect package installation and release distribution with transactional safety.
+
+## In Scope
+- Package validation
+- Backup and rollback
+- Compatibility checks
+- Forbidden-file detection
+- Publish hygiene and provenance
+
+## Must-Have Checks
+- Preflight validation before installation or publish
+- Backup point before mutating user state
+- Automatic rollback on failure
+- Compatibility manifest present
+- Evidence bundle attached to release
+
+## Evidence
+- Install validation report
+- Rollback verification log
+- Publish dry-run output
+- Integrity and provenance manifest
+
+## Fallback
+- If automated rollback cannot be guaranteed, the operation must stop before mutation.

package/.agent-context/skills/frontend/README.md

@@ -0,0 +1,36 @@
+# Frontend Engineering Skills
+
+The frontend domain covers component architecture, state management, performance optimization, accessibility, motion design, and visual polish. Content consolidated from **minimax-ai/skills** (design focus), **awesome-copilot** (architectural patterns), and **antigravity-awesome-skills** (React patterns), with production-grade automation and enforcement.
+
+## Topics
+- [UI Architecture](ui-architecture.md) - Smart/Dumb components, state management, composition patterns
+- [Accessibility](accessibility.md) - WCAG compliance, keyboard navigation, semantic HTML, color contrast
+- [Motion](motion.md) - Animation patterns, performance, CSS containment
+- [Performance](performance.md) - Memoization, code splitting, bundle gates, profiling
+
+## What Makes Ours Different
+
+- Smart/Dumb Architecture (awesome-copilot) + animation system patterns (minimax) + React patterns (antigravity)
+- Anti-Slop Enforcer (ABOVE LINE) - Detect forbidden visual patterns and style drift
+- Accessibility Auditor (ABOVE LINE) - Detect contrast failures, ARIA issues, and keyboard navigation gaps
+- Performance Budget Enforcer (ABOVE LINE) - Bundle size gates and LCP/FID/CLS thresholds
+
+## Recommended Reading Order
+
+1. `ui-architecture.md` - Mental models first (EXPERT)
+2. `accessibility.md` - Compliance baseline (EXPERT)
+3. `motion.md` - Design patterns and optimization (EXPERT)
+4. `performance.md` - Profiling and gates (EXPERT)
+
+## Coverage vs 3 Repos
+
+| Aspect | antigravity | awesome-copilot | MiniMax | Ours |
+|--------|-------------|-----------------|---------|------|
+| Component Patterns | Medium | High | Medium | High + quality gates |
+| Animation Patterns | Low | Low | High | High + performance rules |
+| Accessibility | Medium | High | Medium | High + automated audits |
+| Automation | None | None | None | Anti-slop, accessibility, and performance tooling |
+
+## Default Tier Behavior
+- Use `advance` for typical web apps (1500+ employees)
+- Escalate to `expert` when component library, state complexity, or accessibility/performance tuning is critical

package/.agent-context/skills/frontend/accessibility.md

@@ -0,0 +1,107 @@
+# Accessibility and Inclusive Interaction
+
+**Tier:** EXPERT | **Source:** awesome-copilot (WCAG) + minimax (motion and dark mode) + antigravity (UX patterns)
+
+## Purpose
+
+Accessibility is a production requirement. Inclusive interaction reduces support burden, improves usability, and prevents last-minute retrofit work.
+
+## Part 1: Semantic Structure
+
+Use native HTML elements first. They provide keyboard support, roles, and state semantics without extra work.
+
+```javascript
+<nav>
+  <button aria-expanded={isOpen} aria-controls="menu-panel">Menu</button>
+  <ul id="menu-panel" hidden={!isOpen}>
+    <li><a href="/">Home</a></li>
+    <li><a href="/about">About</a></li>
+  </ul>
+</nav>
+```
+
+Avoid replacing native controls with generic containers unless there is a specific reason.
+
+## Part 2: Keyboard Support
+
+Every interactive control must be reachable and operable by keyboard.
+
+- Tab order should follow the visual order.
+- Enter and Space should activate buttons and custom controls.
+- Focus should never get trapped unless a modal or dialog deliberately manages it.
+- Skip links should exist on content-heavy pages.
+
+```javascript
+<div
+  role="button"
+  tabIndex={0}
+  onClick={handleDelete}
+  onKeyDown={(event) => {
+    if (event.key === 'Enter' || event.key === ' ') {
+      handleDelete();
+    }
+  }}
+>
+  Delete
+</div>
+```
+
+## Part 3: Contrast and Text Scaling
+
+- Normal text contrast should meet WCAG AA minimums.
+- Large text may use the relaxed large-text ratio, but still needs clear contrast.
+- Layouts should survive zoom and text scaling without truncation.
+- Avoid fixed-height containers that clip longer translated content.
+
+## Part 4: Screen Reader Support
+
+Use accessible names and state descriptions.
+
+```javascript
+<button aria-label="Close menu" onClick={handleClose}>
+  X
+</button>
+```
+
+If content updates dynamically, use live regions only when needed and keep them concise.
+
+## Part 5: Motion and Reduced Motion
+
+Animations should respect reduced-motion settings. Motion must support understanding, not create distraction.
+
+```javascript
+const prefersReducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+
+const menuVariants = {
+  open: {
+    opacity: 1,
+    transition: prefersReducedMotion ? { duration: 0 } : { duration: 0.2 }
+  }
+};
+```
+
+## Part 6: Forms and Error Messaging
+
+- Every input needs a visible label.
+- Error messages should describe the problem and how to fix it.
+- Validation should be announced in a way screen readers can reach.
+- Do not rely on color alone to communicate state.
+
+## Part 7: Testing Approach
+
+Test accessibility with a mix of manual and automated checks.
+
+- Automated scans for contrast, labels, and roles.
+- Keyboard-only navigation passes for critical flows.
+- Screen-reader spot checks for key screens.
+- Motion tests for reduced-motion behavior.
+
+## Review Checklist
+
+- [ ] Semantic elements are used first.
+- [ ] Keyboard operation is complete.
+- [ ] Contrast and zoom behavior are acceptable.
+- [ ] Accessible names exist for icon-only controls.
+- [ ] Reduced-motion behavior is implemented.
+- [ ] Form labels and errors are clear.
+- [ ] Critical flows are tested with keyboard and screen readers.

package/.agent-context/skills/frontend/motion.md

@@ -0,0 +1,67 @@
+# Motion Design and Implementation
+
+Tier: EXPERT
+
+Motion is part of product behavior. It should clarify state changes, guide focus, and provide feedback without reducing accessibility or performance.
+
+## Motion Intent Model
+
+Use motion only for one of these intents:
+- Transition intent: communicate screen or state transition.
+- Feedback intent: confirm user action success/failure.
+- Focus intent: direct attention to newly relevant content.
+
+If a transition has no intent, remove it.
+
+## Timing and Consistency
+
+Adopt a small timing scale and reuse it across the product:
+- Fast: 120ms for micro-feedback.
+- Standard: 200ms to 260ms for component transitions.
+- Slow: 320ms to 420ms for route transitions.
+
+Avoid mixing unrelated easing curves in one flow.
+
+## Performance-Safe Animation Rules
+
+Prefer animating properties that do not trigger expensive layout and paint work:
+- Preferred: transform, opacity.
+- Avoid for frequent animation: top, left, width, height, box-shadow blur radius.
+
+Use CSS containment and selective `will-change` only for elements that actually animate.
+
+## Reduced Motion Compliance
+
+Always implement reduced-motion fallback:
+
+```css
+.panel {
+	transition: transform 220ms ease, opacity 220ms ease;
+}
+
+@media (prefers-reduced-motion: reduce) {
+	.panel {
+		transition: none;
+	}
+}
+```
+
+## Interaction Patterns
+
+Recommended patterns:
+- Enter/exit fade + translate for dialogs.
+- Staggered list reveal for scannability on load.
+- Subtle press/hover feedback for actionable controls.
+
+Avoid these patterns:
+- Continuous decorative motion on primary content.
+- Multiple competing animations in one viewport.
+- Looping movement that can distract reading flow.
+
+## Review Checklist
+
+- [ ] Every animation has explicit product intent.
+- [ ] Timing scale is consistent across components.
+- [ ] Heavy layout-triggering properties are avoided.
+- [ ] Reduced-motion mode is implemented and tested.
+- [ ] Motion does not block keyboard or screen-reader flow.

package/.agent-context/skills/frontend/performance.md

@@ -0,0 +1,63 @@
+# Frontend Performance Engineering
+
+Tier: EXPERT
+
+Performance work should be evidence-driven. Start with baseline metrics, optimize where bottlenecks are proven, then verify that user-facing indicators improved.
+
+## Core Metrics
+
+Track Core Web Vitals in CI and release checks:
+- LCP target: less than 2.5s on reference environments.
+- INP target: less than 200ms.
+- CLS target: less than 0.1.
+
+Also track bundle size and script execution time for key routes.
+
+## Render Efficiency
+
+Common controls:
+- Keep expensive computation outside render path with memoization.
+- Use stable callbacks for memoized child components.
+- Split large component trees by feature boundary.
+
+```javascript
+const visibleRows = useMemo(() => {
+	return allRows.filter((row) => row.isVisible);
+}, [allRows]);
+
+const handleRowOpen = useCallback((rowId) => {
+	openRowDetails(rowId);
+}, [openRowDetails]);
+```
+
+## Network and Caching Strategy
+
+- Treat server state separately from UI state.
+- Use query caching with explicit stale policies.
+- Avoid duplicate API calls by keying requests consistently.
+
+For route transitions, prefetch data for likely next navigation paths.
+
+## Bundle Governance
+
+Use route and component-level code splitting:
+- Lazy-load non-critical routes.
+- Defer optional heavy modules until needed.
+- Audit bundle growth at each release.
+
+Set a budget and fail CI on unapproved bundle-size regressions.
+
+## Diagnostics Workflow
+
+1. Capture baseline profile and web-vitals report.
+2. Apply one optimization change.
+3. Re-profile and compare deltas.
+4. Keep only changes with measurable improvement.
+
+## Review Checklist
+
+- [ ] Core metrics targets are monitored and reported.
+- [ ] Render-heavy paths are profiled with tooling evidence.
+- [ ] Data fetching uses cache and deduplication strategy.
+- [ ] Bundle-size budget is defined and enforced.
+- [ ] Performance regressions are blocked until reviewed.

package/.agent-context/skills/frontend/ui-architecture.md

@@ -0,0 +1,128 @@
+# Component Architecture and State Management
+
+**Tier:** EXPERT | **Source:** awesome-copilot (smart/dumb) + minimax (design systems) + antigravity (React patterns)
+
+## Purpose
+
+UI architecture decides how state, behavior, and presentation are split. Good structure reduces re-render churn, keeps component boundaries stable, and makes features easier to test.
+
+## Part 1: Smart and Dumb Separation
+
+A smart component owns data flow, side effects, and orchestration. A dumb component renders input and emits events.
+
+```javascript
+function PaymentFormContainer() {
+  const [amount, setAmount] = useState('');
+  const [status, setStatus] = useState('idle');
+  const [errorMessage, setErrorMessage] = useState(null);
+
+  const handleSubmit = async (submittedAmount) => {
+    setStatus('loading');
+    try {
+      const response = await fetch('/api/payments', {
+        method: 'POST',
+        body: JSON.stringify({ amount: submittedAmount })
+      });
+
+      if (!response.ok) {
+        throw new Error('Payment request failed');
+      }
+
+      setStatus('success');
+    } catch (caughtError) {
+      setErrorMessage(caughtError.message);
+      setStatus('error');
+    }
+  };
+
+  return (
+    <PaymentFormView
+      amount={amount}
+      isLoading={status === 'loading'}
+      errorMessage={errorMessage}
+      onAmountChange={setAmount}
+      onSubmit={handleSubmit}
+    />
+  );
+}
+```
+
+```javascript
+function PaymentFormView({ amount, isLoading, errorMessage, onAmountChange, onSubmit }) {
+  return (
+    <form onSubmit={(event) => { event.preventDefault(); onSubmit(amount); }}>
+      <input
+        value={amount}
+        onChange={(event) => onAmountChange(event.target.value)}
+        disabled={isLoading}
+      />
+      <button disabled={isLoading}>
+        {isLoading ? 'Processing' : 'Pay'}
+      </button>
+      {errorMessage ? <p>{errorMessage}</p> : null}
+    </form>
+  );
+}
+```
+
+## Part 2: State Ownership Rules
+
+Use the smallest useful state scope.
+
+- Local component state: form fields, toggles, ephemeral UI state.
+- Shared UI state: theme, sidebar state, modal visibility.
+- Server state: remote data, caching, invalidation, refetching.
+- Derived state: compute from existing data instead of duplicating it.
+
+Recommended mapping:
+- `useState` for local state.
+- `Zustand` or context for global UI state.
+- `TanStack Query` for server state.
+- Avoid context for high-frequency server data when query caching is the better fit.
+
+## Part 3: Composition and Contracts
+
+A component contract should define what it accepts, what it renders, and what events it emits.
+
+```javascript
+interface ButtonProps {
+  variant?: 'primary' | 'secondary' | 'danger';
+  size?: 'small' | 'medium' | 'large';
+  disabled?: boolean;
+  loading?: boolean;
+  onClick: () => void;
+  children: React.ReactNode;
+}
+```
+
+Keep public component APIs stable. If the component grows many optional props, split it into smaller feature-specific components instead of adding more flags.
+
+## Part 4: Anti-Patterns
+
+- Prop drilling across many levels.
+- Global context for everything.
+- Mixing network calls into presentational views.
+- Repeating derived values in both state and render.
+- Reaching into another feature's internals instead of using the feature public API.
+
+## Part 5: Design System Integration
+
+Design tokens should drive spacing, color, and sizing. Avoid one-off values unless the design system explicitly allows them.
+
+```javascript
+const buttonStyles = {
+  primary: 'bg-primary text-on-primary',
+  secondary: 'bg-surface text-primary',
+  danger: 'bg-danger text-on-danger'
+};
+```
+
+## Review Checklist
+
+- [ ] Smart and dumb layers are separated.
+- [ ] State ownership is minimal and deliberate.
+- [ ] Server state uses a cache-aware tool.
+- [ ] Component contracts are explicit and stable.
+- [ ] Feature boundaries are respected.
+- [ ] Design tokens are used consistently.
+- [ ] Prop drilling does not replace composition or shared state.

package/.agent-context/skills/frontend.md

@@ -0,0 +1,30 @@
+# Frontend Skill Pack
+
+Default tier: `advance`
+
+## Purpose
+Deliver frontend experiences that are visually intentional, accessible, and efficient.
+
+## In Scope
+- UI architecture and component composition
+- Responsive layouts and breakpoints
+- Motion, animation, and interaction polish
+- Accessibility and keyboard flows
+- Conversion clarity and onboarding flow
+
+## Must-Have Checks
+- Feature-driven folder structure
+- Smart and dumb component separation
+- Server state and client state separation
+- Reduced-motion fallback
+- Accessibility baseline pass
+- Responsive behavior verified on mobile and desktop
+
+## Evidence
+- Usability audit result
+- Visual regression output
+- Accessibility checklist result
+- Release notes for motion and interaction changes
+
+## Fallback
+- If a feature cannot meet the advance tier, ship standard mode only as a temporary compatibility path.

package/.agent-context/skills/fullstack/README.md

@@ -0,0 +1,19 @@
+# Fullstack Engineering Skills
+
+Default tier: `advance`
+
+This domain connects frontend and backend implementation into a single feature-delivery workflow. The guidance combines architecture patterns from awesome-copilot, operational checklists from MiniMax, and practical delivery patterns from antigravity.
+
+## Topics
+- [Feature Slicing](feature-slicing.md) - Organize UI, service, repository, and tests around one business capability
+- [Contracts](contracts.md) - Keep API schemas, DTOs, and frontend types synchronized
+- [End-to-End](end-to-end.md) - Release readiness by verified user journeys and operational gates
+
+## Operating Model
+- Use `advance` for normal feature development.
+- Escalate to `expert` when a feature crosses multiple bounded contexts or service boundaries.
+
+## Above-Line Additions
+- Contract drift detection in CI before merge.
+- Backward-compatibility checks for API changes.
+- Release evidence bundle for end-to-end readiness.

package/.agent-context/skills/fullstack/contracts.md

@@ -0,0 +1,53 @@
+# Contracts
+
+Tier: EXPERT
+
+Contracts keep frontend expectations and backend behavior aligned through explicit schemas. A contract is not documentation only; it is an executable guardrail.
+
+## Contract Sources
+
+- API specification: OpenAPI 3.1 for HTTP boundaries.
+- Runtime validation: Zod/Pydantic at service edges.
+- Type generation: frontend types generated from server contract.
+
+## Required Pipeline
+
+1. Define or update schema in contract source.
+2. Regenerate consumer types.
+3. Run contract tests against provider and consumer.
+4. Fail CI if drift is detected.
+
+## Drift Prevention
+
+Common drift scenarios:
+- Backend renames field but frontend still expects old key.
+- Enum expands or changes values without consumer handling.
+- Response shape changes silently in minor release.
+
+Control strategy:
+- Pin contract artifact version.
+- Require schema diff check in pull request.
+- Block merge on unreviewed breaking changes.
+
+## Breaking Change Policy
+
+- Additive changes: allowed in minor version if backward-compatible.
+- Behavioral changes: require release note and migration note.
+- Breaking schema changes: major version bump with compatibility plan.
+
+## Example Workflow
+
+```text
+contracts/openapi.yaml updated
+-> generate frontend types
+-> run provider contract tests
+-> run consumer compatibility tests
+-> publish artifact only if all checks pass
+```
+
+## Review Checklist
+
+- [ ] Contract source is versioned and reviewed.
+- [ ] Provider and consumer tests both pass.
+- [ ] Breaking changes are tagged and documented.
+- [ ] Migration path is included before release.