ui/src/features/dags/components/dag-details/DAGHeader.tsx (2)

70-70: Missing calculateDuration in useEffect dependency array.

calculateDuration is called inside this effect but not listed as a dependency. While the individual fields it closes over are partially covered, this is fragile — if calculateDuration's dependencies change in the future, this effect won't re-fire.

Proposed fix

-  }, [isRunning, dagRunToDisplay?.startedAt, dagRunToDisplay?.finishedAt]);
+  }, [isRunning, dagRunToDisplay?.startedAt, dagRunToDisplay?.finishedAt, calculateDuration]);

---

88-130: handleRefresh is not memoized, causing the keydown listener to be re-attached every render.

handleRefresh is a plain function (recreated each render) and is listed in the useEffect dependency array at Line 130. This means the keydown event listener is removed and re-added on every render cycle. Wrap it in useCallback.

Proposed fix

-  const handleRefresh = () => {
+  const handleRefresh = useCallback(() => {
     setIsRefreshing(true);
     refreshFn();
     setTimeout(() => setIsRefreshing(false), 600);
-  };
+  }, [refreshFn]);

internal/service/frontend/agent_policy.go (1)

76-80: Confirm that silently allowing denied commands when SafeMode is off is the intended security posture.

When SafeMode is false and the deny behavior is ask_user (the default), all policy-denied bash commands are silently allowed without any prompt or audit log entry. This means that agent steps running without SafeMode effectively bypass ask_user deny rules entirely.

Consider whether an audit log entry should still be emitted here for observability, even when the command is allowed:

🔍 Suggested audit logging

 	if decision.DenyBehavior == agent.BashDenyBehaviorAskUser && !info.SafeMode {
+		details["approval_result"] = "safe_mode_off_bypass"
+		logPolicyEvent(ctx, auditSvc, info, auditActionToolPolicyOverride, details)
 		return nil
 	}

internal/core/exec/context.go (1)

30-31: any-typed fields lose compile-time safety — consider defining minimal interfaces in this package.

The any typing is a valid workaround for circular imports, and the comments explain it well. However, every consumer must perform a runtime type assertion, which can silently produce nil values if the wrong type is stored. If more fields follow this pattern, consider defining narrow interfaces (e.g., AgentConfigProvider, AgentModelProvider) in the exec package to restore compile-time guarantees without importing the agent package.

Not blocking — the current approach is pragmatic for the scope of this PR.

internal/cmd/context.go (1)

412-432: Extract shared agentStores helper to avoid duplication.

The agentStores() implementation here is nearly identical to remoteTaskHandler.agentStores() in internal/service/worker/remote_handler.go—both use the same fileagentconfig.New and fileagentmodel.New calls with identical error handling, and both hardcode the "agent/models" sub-path. Additionally, internal/service/frontend/server.go uses the same pattern inline. Extract a shared helper (in the persistence layer or a small internal package) to centralize the path constant "agent/models" and keep store-creation logic consistent across callers.

internal/runtime/builtin/agentstep/executor.go (2)

209-247: Deterministic tool ordering would improve reproducibility.

Map iteration order is nondeterministic; using a fixed ordering avoids prompt/test flakiness.

🔧 Suggested ordering

-	// Default: all globally-enabled tools.
-	var tools []*agent.AgentTool
-	for _, tool := range allTools {
-		tools = append(tools, tool)
-	}
-	return tools
+	// Default: all globally-enabled tools in deterministic order.
+	order := []string{"bash", "read", "patch", "think", "read_schema", "web_search", "output"}
+	var tools []*agent.AgentTool
+	for _, name := range order {
+		if tool, ok := allTools[name]; ok {
+			tools = append(tools, tool)
+		}
+	}
+	return tools

---

295-335: Consider using structured logger helpers for agent logs.

logf/logMessage emit raw strings; routing through internal/common logging would keep consistent structure and fields.

As per coding guidelines, "Prefer idiomatic Go patterns, minimal global state, and structured logging helpers in internal/common".