fix(ci): resolve 68 ruff lint errors

- Remove unused variables (F841): coordinator, inventory_optimizer, kpi engine, risk_tools, test
- Break long lines (E501): orchestrator agent tool lists and dict comprehension
- Add strict=False to zip() calls (B905): athena, redshift, forecaster
- Rename unused loop vars (B007): optimizer gen/ep/day → _gen/_ep/_day
- Move Protocol import to top of file (E402): forecaster
- Add noqa for validated SQL queries (S608): aws_backend
- Suppress false positives in ruff config: S311 (simulation random), S104 (server bind)
- Add per-file-ignores for test passwords: S106

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: hsinnearth7

chaincommand/agents/coordinator.py

@@ -45,7 +45,6 @@ async def run_cycle(self, context: Dict[str, Any]) -> Dict[str, Any]:
         }
 
         agent_results = context.get("agent_results", {})
-        products = context.get("products", [])
 
         # Step 1: Conflict detection and resolution
         conflicts = self._detect_conflicts(agent_results)

chaincommand/agents/inventory_optimizer.py

@@ -43,7 +43,7 @@ async def run_cycle(self, context: Dict[str, Any]) -> Dict[str, Any]:
             description="Check all inventory levels",
             input_data={},
         )
-        inv_data = await self.act(inv_action)
+        await self.act(inv_action)
         results["actions"].append(inv_action.model_dump())
 
         products = context.get("products", [])

chaincommand/aws/athena_client.py

@@ -145,7 +145,7 @@ def get_query_results(self, execution_id: str) -> List[Dict[str, Any]]:
         results = []
         for row in rows[1:]:
             values = [col.get("VarCharValue", "") for col in row["Data"]]
-            results.append(dict(zip(headers, values)))
+            results.append(dict(zip(headers, values, strict=False)))
         return results
 
     def _start_query(self, sql: str) -> str:

chaincommand/aws/aws_backend.py

@@ -114,7 +114,7 @@ async def query_kpi_trend(self, metric: str, days: int) -> list:
 
         safe_days = max(1, min(int(days), 365))
         sql = (
-            f"SELECT cycle, timestamp, {metric} "
+            f"SELECT cycle, timestamp, {metric} "  # noqa: S608
             f"FROM kpi_snapshots "
             f"WHERE timestamp >= DATEADD(day, -{safe_days}, GETDATE()) "
             f"ORDER BY cycle"
@@ -128,7 +128,7 @@ async def query_events(self, event_type: str, limit: int) -> list:
             return []
         safe_limit = max(1, min(int(limit), 500))
         sql = (
-            f"SELECT event_id, timestamp, event_type, severity, source_agent, description "
+            f"SELECT event_id, timestamp, event_type, severity, source_agent, description "  # noqa: S608
             f"FROM events "
             f"WHERE event_type = '{event_type}' "
             f"ORDER BY timestamp DESC "

chaincommand/aws/redshift_client.py

@@ -190,7 +190,7 @@ def query(self, sql: str, params: Optional[Tuple] = None) -> List[Dict[str, Any]
         columns = [desc[0] for desc in cursor.description] if cursor.description else []
         rows = cursor.fetchall()
         cursor.close()
-        return [dict(zip(columns, row)) for row in rows]
+        return [dict(zip(columns, row, strict=False)) for row in rows]
 
     def insert_kpi_snapshot(self, cycle: int, snapshot: KPISnapshot) -> None:
         """Direct INSERT of a KPI snapshot row."""

chaincommand/kpi/engine.py

@@ -37,7 +37,7 @@ def calculate_snapshot(
         on_time_in_full = 0
         for po in delivered:
             if po.expected_delivery and po.created_at:
-                on_time = True  # simplified: assume delivered POs are on-time
+                # simplified: assume delivered POs are on-time
                 on_time_in_full += 1
         otif = on_time_in_full / max(len(delivered), 1)
 

chaincommand/models/forecaster.py

@@ -4,7 +4,7 @@
 
 import random
 from datetime import datetime, timedelta
-from typing import Dict, List
+from typing import Dict, List, Protocol, runtime_checkable
 
 import numpy as np
 import pandas as pd
@@ -202,7 +202,7 @@ def predict(self, product_id: str, horizon: int = 30) -> List[ForecastResult]:
             return lstm_preds
 
         results = []
-        for lstm_r, xgb_r in zip(lstm_preds, xgb_preds):
+        for lstm_r, xgb_r in zip(lstm_preds, xgb_preds, strict=False):
             w_l, w_x = weights["lstm"], weights["xgb"]
             demand = w_l * lstm_r.predicted_demand + w_x * xgb_r.predicted_demand
             lower = w_l * lstm_r.confidence_lower + w_x * xgb_r.confidence_lower
@@ -232,16 +232,14 @@ def _compute_mape(actual: np.ndarray, predicted: List[float]) -> float:
         if n == 0:
             return 100.0
         errors = []
-        for a, p in zip(actual[:n], predicted[:n]):
+        for a, p in zip(actual[:n], predicted[:n], strict=False):
             if a > 0:
                 errors.append(abs(a - p) / a * 100)
         return float(np.mean(errors)) if errors else 100.0
 
 
 # ── v2.0: ForecastModel Protocol ─────────────────────────
 
-from typing import Protocol, runtime_checkable
-
 
 @runtime_checkable
 class ForecastModel(Protocol):

chaincommand/models/optimizer.py

@@ -54,7 +54,7 @@ def optimize(
         best = population[0]
         best_fitness_val = -1.0
 
-        for gen in range(self._generations):
+        for _gen in range(self._generations):
             # Fitness = minimize total cost (holding + stockout penalty + ordering)
             fitness = []
             for individual in population:
@@ -142,11 +142,11 @@ def train(self, product: Product) -> None:
         }
 
         epsilon = self._epsilon
-        for ep in range(self._episodes):
+        for _ep in range(self._episodes):
             stock = product.current_stock
             total_reward = 0
 
-            for day in range(30):
+            for _day in range(30):
                 # State discretization
                 stock_level = "critical" if stock < product.safety_stock else \
                               "low" if stock < product.reorder_point else \

chaincommand/orchestrator.py

@@ -187,19 +187,28 @@ async def _ui_event_handler(event: Any) -> None:
         _runtime.agents = {
             "demand_forecaster": DemandForecasterAgent(
                 llm=llm,
-                tools=[QueryDemandHistory(), RunDemandForecast(), GetForecastAccuracy(), ScanMarketIntelligence(), EmitEvent()],
+                tools=[
+                    QueryDemandHistory(), RunDemandForecast(), GetForecastAccuracy(),
+                    ScanMarketIntelligence(), EmitEvent(),
+                ],
             ),
             "strategic_planner": StrategicPlannerAgent(
                 llm=llm,
                 tools=[QueryKPIHistory(), OptimizeInventory(), QueryInventoryStatus(), EmitEvent()],
             ),
             "inventory_optimizer": InventoryOptimizerAgent(
                 llm=llm,
-                tools=[QueryInventoryStatus(), CalculateReorderPoint(), AdjustSafetyStock(), OptimizeInventory(), EmitEvent()],
+                tools=[
+                    QueryInventoryStatus(), CalculateReorderPoint(), AdjustSafetyStock(),
+                    OptimizeInventory(), EmitEvent(),
+                ],
             ),
             "supplier_manager": SupplierManagerAgent(
                 llm=llm,
-                tools=[QuerySupplierInfo(), EvaluateSupplier(), CreatePurchaseOrder(), RequestHumanApproval(), EmitEvent()],
+                tools=[
+                    QuerySupplierInfo(), EvaluateSupplier(), CreatePurchaseOrder(),
+                    RequestHumanApproval(), EmitEvent(),
+                ],
             ),
             "logistics_coordinator": LogisticsCoordinatorAgent(
                 llm=llm,
@@ -387,7 +396,10 @@ async def run_cycle(self) -> Dict[str, Any]:
 
         return {
             "cycle": self._cycle_count,
-            "agent_results": {k: v.get("analysis", "") if isinstance(v, dict) else "" for k, v in agent_results.items()},
+            "agent_results": {
+                k: v.get("analysis", "") if isinstance(v, dict) else ""
+                for k, v in agent_results.items()
+            },
             "kpi": snapshot.model_dump(),
             "violations": len(violations),
             "report": report_result.get("report", {}).get("report_id"),

chaincommand/tools/risk_tools.py

@@ -59,7 +59,6 @@ async def execute(self, **kwargs: Any) -> Dict[str, Any]:
         supplier_id: str = kwargs.get("supplier_id", "")
 
         suppliers = _runtime.suppliers or []
-        products = _runtime.products or []
 
         # Find relevant suppliers
         if product_id: